﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.TraceVisualiser.Pics
{
	public static class PicLibrary16
	{
		#region Image AlignFillCenter
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-center.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu AlignFillCenter_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property AlignFillCenter, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignFillCenter_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-center.png
		/// </remarks>
		public static System.Drawing.Image AlignFillCenter_Cached
		{
			get
			{
				if (_AlignFillCenter == null) _AlignFillCenter = AlignFillCenter;
				return _AlignFillCenter;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-center.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image AlignFillCenter_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillCenter_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillCenter_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-center.png
		/// </remarks>
		public static System.Drawing.Image AlignFillCenter { get { return _ImageCreateFrom(_AlignFillCenter_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru align-fill-center.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillCenter_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillCenter_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-center.png
		/// </remarks>
		public static System.Drawing.Image AlignFillCenter_FromFile { get { return _ImageCreateFrom(_AlignFillCenter_string, "align-fill-center.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru AlignFillCenter
		/// </summary>
		/// <returns></returns>
		private static string _AlignFillCenter_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1136);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAARJJREFUOMulkjFOxDAURCdhRYFQCii5AbfgBnsIbsA5aHIAzkDBMahpQaJIh2hYkfz/ZyjsLMkmG5BiybIta96f8XchCWtGuXRZ1/Wf9GLo");
			sb.Append("4PF5tz8EAQqIAJyA5/X25qwYAjaHxMvzEuzFBCKvpPD+ERMHI4AAkL9CMlUllc5T/RjQ26WS5QTTCLYI8ACaT+7zMtI+lKAzekDS0bndbrV0Lyl14f6pmbTLXXAnzInW");
			sb.Append("AtYSrRHWEZ0HHu6ui1GEq4vT7CjnHgDMT+AmmBPuxMvb1/wbUAID8MhiSwA3wlyIIDyEIKcAKlcN5WoBN6LLTtwFUuDB19/0eV+b76N5vRM8iNl/vfTCVVX9rwtrRrlK");
			sb.Append("DeAHSbpY9KxIOIAAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTZUMjI6MTg6MTctMDc6MDBbAP7BAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA2OjUy");
			sb.Append("OjU5LTA3OjAwx+S29AAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwNjo1Mjo1OS0wNzowMLa5DkgAAABidEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29t");
			sb.Append("bW9ucy5vcmcvbGljZW5zZXMvYnkvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8yLjUvi4Y8ZQAAACV0RVh0bW9kaWZ5LWRhdGUA");
			sb.Append("MjAwNi0wMy0xMlQyMTo1NzoxNC0wNzowMNA5v9kAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAAG3RFWHRTb3VyY2UARkFNRkFNRkFNIFNpbGsg");
			sb.Append("SWNvbnOCemT7AAAAM3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay/CxA0NAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property AlignFillCenter_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void AlignFillCenter_Reset()
		{
			_AlignFillCenter = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití AlignFillCenter_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _AlignFillCenter = null;
		#endregion
		#region Image AlignFillLeft
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-left.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu AlignFillLeft_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property AlignFillLeft, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignFillLeft_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-left.png
		/// </remarks>
		public static System.Drawing.Image AlignFillLeft_Cached
		{
			get
			{
				if (_AlignFillLeft == null) _AlignFillLeft = AlignFillLeft;
				return _AlignFillLeft;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-left.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image AlignFillLeft_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillLeft_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillLeft_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-left.png
		/// </remarks>
		public static System.Drawing.Image AlignFillLeft { get { return _ImageCreateFrom(_AlignFillLeft_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru align-fill-left.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillLeft_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillLeft_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-left.png
		/// </remarks>
		public static System.Drawing.Image AlignFillLeft_FromFile { get { return _ImageCreateFrom(_AlignFillLeft_string, "align-fill-left.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru AlignFillLeft
		/// </summary>
		/// <returns></returns>
		private static string _AlignFillLeft_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1164);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAASVJREFUOMutkz1KBEEQhb9ZxEBkAw2NvYSZt/AAZp7FZMF7GHgMcwMzRcxE2J0fu6teGfQ4u8MsIrsWNF3d8L56XUVXEcE+MQNYLBY7Uw4A");
			sb.Append("uq4D4P6xGUAuUIA7mMD6/fryqJoAmqYZLk6PZ+hHLPB+l4LXD9/uoK5rAAKQ1kKpVJWinKf6AlitVsV2b1NRLBdYjGC/Aszh/VPDe+Ul9yjQLfox4Opi3KA/T2G5XAJw");
			sb.Append("+/A+Gad7YCayBzkFKTs5i5TF3c15NQIAnJ0cAqAI5BsAE+bCbIZl8fRST6cAENE3zgN3YRZkE56D3J/dRfelbVMo1cwDsz43kfvcTQNc2gC0bQtASuL5rSUlJ1t5Z07F");
			sb.Append("fk6Bx1q4YTmYz+cREeyyqn/5jfvEN1maQHPNwIsUAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE3LTA3OjAwWwD+wQAAACV0RVh0ZGF0ZTpjcmVh");
			sb.Append("dGUAMjAxMC0wMS0xMVQwNjo1Mjo1NS0wNzowMABE3IAAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTI6NTUtMDc6MDBxGWQ8AAAAYnRFWHRMaWNlbnNl");
			sb.Append("AGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uGPGUA");
			sb.Append("AAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NTc6MTQtMDc6MDDQOb/ZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0U291");
			sb.Append("cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAAAABJ");
			sb.Append("RU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property AlignFillLeft_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void AlignFillLeft_Reset()
		{
			_AlignFillLeft = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití AlignFillLeft_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _AlignFillLeft = null;
		#endregion
		#region Image AlignFillRight
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-right.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu AlignFillRight_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property AlignFillRight, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignFillRight_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-right.png
		/// </remarks>
		public static System.Drawing.Image AlignFillRight_Cached
		{
			get
			{
				if (_AlignFillRight == null) _AlignFillRight = AlignFillRight;
				return _AlignFillRight;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku align-fill-right.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image AlignFillRight_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-right.png
		/// </remarks>
		public static System.Drawing.Image AlignFillRight { get { return _ImageCreateFrom(_AlignFillRight_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru align-fill-right.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignFillRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignFillRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-fill-right.png
		/// </remarks>
		public static System.Drawing.Image AlignFillRight_FromFile { get { return _ImageCreateFrom(_AlignFillRight_string, "align-fill-right.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru AlignFillRight
		/// </summary>
		/// <returns></returns>
		private static string _AlignFillRight_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1164);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAASVJREFUOMvFkzFOAzEQRd9GiCJCKaCk5hJ03IID0HEWmkjcg4Jj0FPQgVA6hJRkd7Fn/lB4NyHsIqFQMJLlsaz/5ntsVxHBX2Kyr3A+nwfA");
			sb.Append("wfeNu4d6Y8kFCnAHE1g3X11Mq7ZtGQUAnBxNUC8WeDdLwcubA1DX9TggAGkrlEpVKcq66Fmv1+OA3q6iWC6w2IEBrFarcYA5LN61Oa+85B4F2ul/BlyeT6vf3MIO4OZ+");
			sb.Append("MXgM7oGZyB7kFKTs5CxSFrfXZ9Vyudx1cHp8CIAikH8BmDAXZhMsi8fn0rwBIKJrlgfuwizIJjwHuVu7i/ZDw1voq5kHZl1uIne5mzZwScMepCSeXhtScrKVc+ZU7OcU");
			sb.Append("eGyFfTRN01uPvcZsNouIoPq339jHJ/T2QHP0mSc8AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE3LTA3OjAwWwD+wQAAACV0RVh0ZGF0ZTpjcmVh");
			sb.Append("dGUAMjAxMC0wMS0xMVQwNjo1MzowMi0wNzowMGLBh1QAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTM6MDItMDc6MDATnD/oAAAAYnRFWHRMaWNlbnNl");
			sb.Append("AGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uGPGUA");
			sb.Append("AAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NTc6MTYtMDc6MDBHpq7wAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0U291");
			sb.Append("cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAAAABJ");
			sb.Append("RU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property AlignFillRight_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void AlignFillRight_Reset()
		{
			_AlignFillRight = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití AlignFillRight_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _AlignFillRight = null;
		#endregion
		#region Image AlignHorizontalCenter
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-center.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu AlignHorizontalCenter_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property AlignHorizontalCenter, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignHorizontalCenter_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-center.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalCenter_Cached
        {
            get
            {
                if (_AlignHorizontalCenter == null) _AlignHorizontalCenter = AlignHorizontalCenter;
                return _AlignHorizontalCenter;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-center.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image AlignHorizontalCenter_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalCenter_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalCenter_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-center.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalCenter { get { return _ImageCreateFrom(_AlignHorizontalCenter_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru align-horizontal-center.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalCenter_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalCenter_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-center.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalCenter_FromFile { get { return _ImageCreateFrom(_AlignHorizontalCenter_string, "align-horizontal-center.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru AlignHorizontalCenter
        /// </summary>
        /// <returns></returns>
        private static string _AlignHorizontalCenter_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1212);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAQCAYAAAAmlE46AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAOAAAAEABlGs4oAAAB");
            sb.Append("aklEQVQoz32Tu0oDQRSGvzOzm52NQmzFwsY2rQrWQUnnA9jY+QY+gAg+gYWlgp2EIGIrJEUsTaGFjYj9JiS7JqM7FrprLqt/e84/5/KdEeccRTq8er9VAse7Zqco7vGH");
            sb.Append("+onbVsKfkqxiu30fAZUs8DJYAGB1cTiZ39vaWl+aqhhFUaVerwEwGo04OftEBC73hSRJiOOYh4fH/OFJIyLfvRlj6L8PEEBEAVAqlYiiaH5Ga+3sjIiAiKCUwvO8qZzc");
            sb.Append("aEyAcy6vmhm11vi+j7UWY4J5YxiaXrN5nc+wuVwFhJubOyZz5rY6q/JB5ADi06VCKNJqdaYwZOq8hQBsrCRFvp6XYRAR0jTFWou1ltrFBwCvR5/4vo+IMBwOGY/HdLtP");
            sb.Append("FTWJQSlFEAQYY35bLpcJwxARQWudY1GzGAA87/cSM5NzDq11jsWbxVAkpRRaa9I0zdFJo9EsXM75cxWAvbVu4XL+w3H7g6PwW30Bca6UHjitT64AAAAldEVYdGNyZWF0");
            sb.Append("ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI0OjIzLTA3OjAwagRQUgAAACV0RVh0ZGF0");
            sb.Append("ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDoyMy0wNzowMBtZ6O4AAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2Ev");
            sb.Append("My4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTA2LTI0VDEwOjM2OjQ3");
            sb.Append("LTA2OjAwVRY2/AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJM");
            sb.Append("AGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property AlignHorizontalCenter_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void AlignHorizontalCenter_Reset()
        {
            _AlignHorizontalCenter = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití AlignHorizontalCenter_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _AlignHorizontalCenter = null;
        #endregion
        #region Image AlignHorizontalLeft
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-left.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu AlignHorizontalLeft_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property AlignHorizontalLeft, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignHorizontalLeft_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-left.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalLeft_Cached
        {
            get
            {
                if (_AlignHorizontalLeft == null) _AlignHorizontalLeft = AlignHorizontalLeft;
                return _AlignHorizontalLeft;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-left.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image AlignHorizontalLeft_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalLeft_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalLeft_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-left.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalLeft { get { return _ImageCreateFrom(_AlignHorizontalLeft_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru align-horizontal-left.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalLeft_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalLeft_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-left.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalLeft_FromFile { get { return _ImageCreateFrom(_AlignHorizontalLeft_string, "align-horizontal-left.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru AlignHorizontalLeft
        /// </summary>
        /// <returns></returns>
        private static string _AlignHorizontalLeft_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1176);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("T0lEQVQ4y52SPU4jQRCFv67+mZ7IPs0mxCRokUUM9+AGnGQJSdBegYTQCdfoGa00M/3jJsCe9ViLFlPZU3e/el31qfun4ZcoeLjxd3yjTD/UW1EA3L28vAZgdcb7zvRD");
            sb.Append("ZW9ACGF1dXWJUopSCiklUkqUUgBwzjFNE+M4knNmu31bmX6oqL8GqL3QWiMiiAilFKy15JyptWKMQUQIIWD6sbJ/T0ppkU8phXMOgN1uh1IKEZnPUkosEnjfUGudUxyX");
            sb.Append("iGCMwTk3N/K+WRq0bdM9P//+8hDbtulMP+zmjpvN9frsNf6ZAOp3EPgwOBZf5KC7uPix/qfBgQOAaZqIMWKtJcbIOI7EGNlu3xYNTg3meXjvcc6RcwY+uHDOEUL4/Aun");
            sb.Append("HIjIDJTWet794s6xOHBwXFprmqbBWouI4H3zeYK29f/loG19d2rweBCbzc81Z9Y7TuqQtPaNbLgAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzQt");
            sb.Append("MDc6MDC2544SAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI0OjMxLTA3OjAwMTFB5QAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDoz");
            sb.Append("MS0wNzowMEBs+VkAAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21t");
            sb.Append("b25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTA2LTI0VDEwOjM2OjQ3LTA2OjAwVRY2/AAAABl0RVh0U29mdHdhcmUA");
            sb.Append("d3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9y");
            sb.Append("Zy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property AlignHorizontalLeft_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void AlignHorizontalLeft_Reset()
        {
            _AlignHorizontalLeft = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití AlignHorizontalLeft_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _AlignHorizontalLeft = null;
        #endregion
        #region Image AlignHorizontalRight
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-right.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu AlignHorizontalRight_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property AlignHorizontalRight, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property AlignHorizontalRight_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-right.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalRight_Cached
        {
            get
            {
                if (_AlignHorizontalRight == null) _AlignHorizontalRight = AlignHorizontalRight;
                return _AlignHorizontalRight;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku align-horizontal-right.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image AlignHorizontalRight_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalRight_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalRight_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-right.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalRight { get { return _ImageCreateFrom(_AlignHorizontalRight_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru align-horizontal-right.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití AlignHorizontalRight_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property AlignHorizontalRight_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\align-horizontal-right.png
        /// </remarks>
        public static System.Drawing.Image AlignHorizontalRight_FromFile { get { return _ImageCreateFrom(_AlignHorizontalRight_string, "align-horizontal-right.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru AlignHorizontalRight
        /// </summary>
        /// <returns></returns>
        private static string _AlignHorizontalRight_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1160);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("QklEQVQ4y52SPW7cMBBG3wx/RLlZVz6Km63T+Ao5QTqXOZBrF0au4CalG1+DWgSwxJ+li0CEFDiIs9MNOPPwgfOktcYl9f1xflAB+/z8MwKH/9idjsfb69Nb+6oCNsZ4");
            sb.Append("uLv7gohQayXnTM6ZWisA3nuWZWGeZ0opvLy8HgBOb40VgIgAYIxBVVFVaq045yil0FrDWouqEmNkBYiAzTnv8okI3nsAzuczIoKq9rd1/jQ3BLAhDLTWeoptqSrWWrz3");
            sb.Append("fTGEYZ9gHIfp6enHpz9xHIdpC5BLz3hzH5uIYC/aBn4tAG0P+KQT0/F4e702O8DqBMCyLKSUcM6RUmKeZ1JK3YO/Afo1Qgh47ymlAL8d8d53Dz4E/OmEqna5jDE7D/rM");
            sb.Append("tlmd2JYxhmEYcM6hqt2DDxOMY/inE+MYpm1/sQdX3+IDwDsw6ZfINBoSugAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNzowMjozNC0wNzowMLbnjhIAAAAl");
            sb.Append("dEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjQ6MjEtMDc6MDD9m0F7AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjI0OjIxLTA3OjAwjMb5xwAA");
            sb.Append("AGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vu");
            sb.Append("c2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDYtMjRUMTA6MzY6NDctMDY6MDBVFjb8AAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUu");
            sb.Append("b3Jnm+48GgAAABN0RVh0U291cmNlAE94eWdlbiBJY29uc+wYrugAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL+83qssAAAAASUVO");
            sb.Append("RK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property AlignHorizontalRight_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void AlignHorizontalRight_Reset()
        {
            _AlignHorizontalRight = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití AlignHorizontalRight_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _AlignHorizontalRight = null;
        #endregion
        #region Image ArrowRight2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-right-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRight2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRight2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRight2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowRight2_Cached
        {
            get
            {
                if (_ArrowRight2 == null) _ArrowRight2 = ArrowRight2;
                return _ArrowRight2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-right-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRight2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRight2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRight2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowRight2 { get { return _ImageCreateFrom(_ArrowRight2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-right-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRight2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRight2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowRight2_FromFile { get { return _ImageCreateFrom(_ArrowRight2_string, "arrow-right-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRight2
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRight2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1436);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAi1JREFUOMulk09IFGEYxn/fzOzO7syO66oNY1npomSYIVKSUtBNJAi6dIkO3eyfh0CoLuG1Q0URphseKjxV1MkQootkIEQEdQiVoBKUXFdz");
            sb.Append("nXF2Z74OpZBZCr7wwnv68fC8zyOklGxltJUj2pIZrXasQ9+nFyfn5oqXsFPP0S2QUdANSFigxEE1wTSQmSQAygpAlzR1d7WRudGeTtdVPCPn3yUIbcT/FawCQglZqdDQ");
            sb.Append("tpP7Nzs4eWLPOWU5fEkgj28K4BHJjozO8OpDyGdpcrbzINcvH9jnVBhPKMjbhDK+HkCsmChaH7Xiq7dqG3e1tLXvp6TMonkHpKRL3+NvDI/l34e6cZ54YoSEgexPrgEc");
            sb.Append("HgQRs/CUK6ZTdjHdVJswnEoaqwTH9oa8+5jjztMfueyi1kd5okdmku46AP3Xxq1mVL3XtCtaNHs3lhnhzBGoSxa49yLP6wnljRwoaf3jjdj1EPJ7xYJlCFfXVOY9yXwB");
            sb.Append("+kego0ElbsVQIqz6oa3xxKQQXnAco7upwS4fd8tZWhSkt0mKyz6Dw0XP95QBTPXq3wAp64Wkt6Y2dbSypoq3WR1XwvZUQHbGZzYXTIRS7SIqhgC5jgJlqLTKri7alYxN");
            sb.Append("KSRiUBLx+fplGc9XH6JpXYTkCP8RZRGNOUtqKW5eoTQeUPRcpqaDSSm0HjTxYMMuSE1HURRM4bMw6+L5DKKq14DxTSVRqPqnwHWZm81Pez6n0dRTCMbZoKxiq3X+CczA");
            sb.Append("0JglZmfAAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwJK7h4AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0w");
            sb.Append("NzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTg6MzktMDc6MDDwXTGxAAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMu");
            sb.Append("b3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDEtMDc6MDB7H5fUAAAAGXRFWHRTb2Z0d2FyZQBBZG9i");
            sb.Append("ZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251");
            sb.Append("dm9sYS92PbRSAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRight2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRight2_Reset()
        {
            _ArrowRight2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRight2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRight2 = null;
        #endregion
		#region Image ArrowRightDouble
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku arrow-right-double.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu ArrowRightDouble_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property ArrowRightDouble, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRightDouble_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-double.png
		/// </remarks>
		public static System.Drawing.Image ArrowRightDouble_Cached
		{
			get
			{
				if (_ArrowRightDouble == null) _ArrowRightDouble = ArrowRightDouble;
				return _ArrowRightDouble;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku arrow-right-double.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image ArrowRightDouble_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRightDouble_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRightDouble_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-double.png
		/// </remarks>
		public static System.Drawing.Image ArrowRightDouble { get { return _ImageCreateFrom(_ArrowRightDouble_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru arrow-right-double.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRightDouble_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRightDouble_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\arrow-right-double.png
		/// </remarks>
		public static System.Drawing.Image ArrowRightDouble_FromFile { get { return _ImageCreateFrom(_ArrowRightDouble_string, "arrow-right-double.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRightDouble
		/// </summary>
		/// <returns></returns>
		private static string _ArrowRightDouble_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1608);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("50lEQVQ4y4WTTWhcZRSGn+98370zk2lmMsnEzI/5NTWt1oBUpVIoVbSQRbNQ6g8iUsGgVEW6MWAX4g+6UHDhRqEI7qwuat2ISkRaKWGiSWNoimJqK9XmZ9KZ6WTuzNy5");
			sb.Append("93MhFaVqDpzNgfO8B97zsuvQJ++2P/b1gLUWay3uga/02ORnH/RPnNx7bfZ/LclU56E78v6seWhqHCAUrerR/Nj4XTdMRR+ZmmSTkvmVZnn3E/d29PSaT9sf/+ZN44qc");
			sb.Append("Lfqrv9wyrAb3jryROnjyRPzgqcx/AnwRdc7TtI3vIb1ty4ttUfNloCQZ09C4NU9+bHR/MhU7HX/y233/ChAtGGtpNEHt3knPvtv2xBPRfOGiR1CHq+kkqftHB3qG0p8n");
			sb.Append("np4+knhuRv0DgChCr4m96uGve1SciG+25gKp1mitVwlLHuV6iIwOqNyO3KuOli+SL3x/418ApSCsNWlVPIKKR3ClSr3WpKUENuoE5RphqcpGsUo12U7X9ux9sbhbaDs8");
			sb.Append("tx/AIEJQrROUGygFFlCtAL/h44d/qly7uQU0RHHT1lRG/3zxROKphbcN1uJfLtG4UEW0YJUCVyOtgJYfYFEgCqsUxhH6ux16TISlIPQkri8YtIACpRQohYgQjWiiEUVp");
			sb.Append("A/wQrAhtMWEkG8F1Nadmzv/oJ3MPVt4ZWTBKC8pxUFEHbTSd7ZpMymG56NNsgIginTCMZFzWPEWhcO64mx16tHJkuA5glNGIq3FiLr1dDpkOxzlfCsOS72MihoFuh2yH");
			sb.Append("y/zZXzdWL/32Vu3oAy//3UZjjeBEDdv7YjiOZnp+aSGS60/cc/OWvt+9Fo5rOH1m6Qfb3fdw7ZVdi9c9Ujxq7GBnhLXLy0zPLB4jP3SnFC81hlNRWibCdGHxmOQGdxYP");
			sb.Append("9163DED2+Vl7++RcJf3e8gFrLZmjK5J+dmbt7tfXr8SfOf7SZmk0tWL5w5VtO15bnej6CUCJplFdfX9u9rsztY8nPtosjX8AHeVFu1JUovgAAAAldEVYdGNyZWF0ZS1k");
			sb.Append("YXRlADIwMDktMTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI0OjIwLTA3OjAw3nmk+AAAACV0RVh0ZGF0ZTpt");
			sb.Append("b2RpZnkAMjAxMC0wMS0xMVQwODo0Mjo0Mi0wNzowMEN8iVwAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEv");
			sb.Append("O8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMToyOC0wNzowMHeTOt0AAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RFWHRT");
			sb.Append("b3VyY2VfVVJMAGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property ArrowRightDouble_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void ArrowRightDouble_Reset()
		{
			_ArrowRightDouble = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití ArrowRightDouble_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _ArrowRightDouble = null;
		#endregion
		#region Image ColorWheel
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku color-wheel.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu ColorWheel_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property ColorWheel, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ColorWheel_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\color-wheel.png
		/// </remarks>
		public static System.Drawing.Image ColorWheel_Cached
		{
			get
			{
				if (_ColorWheel == null) _ColorWheel = ColorWheel;
				return _ColorWheel;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku color-wheel.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image ColorWheel_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ColorWheel_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ColorWheel_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\color-wheel.png
		/// </remarks>
		public static System.Drawing.Image ColorWheel { get { return _ImageCreateFrom(_ColorWheel_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru color-wheel.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ColorWheel_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ColorWheel_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\color-wheel.png
		/// </remarks>
		public static System.Drawing.Image ColorWheel_FromFile { get { return _ImageCreateFrom(_ColorWheel_string, "color-wheel.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru ColorWheel
		/// </summary>
		/// <returns></returns>
		private static string _ColorWheel_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1816);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAw5JREFUOMtVk01oHGUAhp9v5pvZnc3s7G/+dhMTK/YvNAmkoGCtCo1QqZjiRQhepQdPvSn2IHjwIoiI3kTQi3ooWLCK/0WkBWkpSCA1zeZn");
			sb.Append("u+kmm/2f3dmdnfk81Ej7wHt73+f2CqUUB4hVR8943fOHRHR5WlgzU5qeG9MIRjR/e1Tv35y2el8czvd+5CHEgcBYeeaQ4Zc+OBnJLT2XmGc2/hg50yGhCaKDOoa3ieF9");
			sb.Append("65vV+mdWyX976Ey/+r9ArL4x7QQ7l1+yj86/MHyCuBXgcZckLuPABDajHEO4LfrFn5GF76/qK61l/aKqSVF417S09IdnY3Pzi6NHuG3eIkqNx7GI4hAjxKKLHFxHtC1E");
			sb.Append("5EWUrs723SuXLLgoESPn5iKxV57PznDL3MYhR4YMNiEOFg4hNi6iHYG9MnrzLsHQacLKbxcar4ovZTQysTxnZJFWGp0+aUKy+CTxGUKSACK9FtQ0qPVg8x567jByeNGq");
			sb.Append("Xv/6NWnK/Gw+NsrfCGLksQAHRZaAFGCrABoVqHThfhXum7B3B13P4VeMkxJtcjxpJNgKBTagozAR2AISgOG6D8blKOyYUNShX4NcnsGemJRUI0FomoRd8NV/AboKOgqc");
			sb.Append("XhytkYJW80G6DQg9fM9k4KcC6d+TxbqujsfaArcDTaAagN4DUwMbHaeRgboLbhu8NoxLOrtl/EGyILs75o0NpY6fSgt+XQczAOVBEIAdhSQQa8WQuynYb0GjSfjUCI0b");
			sb.Append("qwwG9jXJmvr8mxX/9dlndZloSna3oO+BYUDVBEdBvCNIN5NQa8KJI9TWi9T+3KlA8itNXTKuuXe8T7/7xeVoIiCrwf4G1ItQ3YLaJuyXwCtH4dgYTSvC9u9FOv3oewvq");
			sb.Append("h3UJQMN/56cr3YnBP73zZxYSzC9GaK6DqoCvQTgBXi6gVeiydXWDxs3mRynsTx45k5gq2ZSqb9mIN18+FXdmnogzmTRIhQGy3CZcq8JflR0zrL2fZvfjBXUhfERwQFTc");
			sb.Append("nh2mtTTM4OmMUFMjKgjGCNfGUH88iXV5SZ0uPNz/Fx45Vd12sHoFAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0RVh0");
			sb.Append("ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwNjo1Mjo1Mi0wNzowMMXj4g4AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTI6NTItMDc6MDC0vlqyAAAAYnRF");
			sb.Append("WHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkv");
			sb.Append("Mi41L4uGPGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NTE6MDgtMDc6MDDWLaV0AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAA");
			sb.Append("ABt0RVh0U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsv");
			sb.Append("wsQNDQAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property ColorWheel_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void ColorWheel_Reset()
		{
			_ColorWheel = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití ColorWheel_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _ColorWheel = null;
		#endregion
        #region Image CrossSword
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossSword.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CrossSword_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CrossSword, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CrossSword_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\CrossSword.png
        /// </remarks>
        public static System.Drawing.Image CrossSword_Cached
        {
            get
            {
                if (_CrossSword == null) _CrossSword = CrossSword;
                return _CrossSword;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CrossSword.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CrossSword_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossSword_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossSword_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\CrossSword.png
        /// </remarks>
        public static System.Drawing.Image CrossSword { get { return _ImageCreateFrom(_CrossSword_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CrossSword.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CrossSword_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CrossSword_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\CrossSword.png
        /// </remarks>
        public static System.Drawing.Image CrossSword_FromFile { get { return _ImageCreateFrom(_CrossSword_string, "CrossSword.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CrossSword
        /// </summary>
        /// <returns></returns>
        private static string _CrossSword_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1200);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAvJJREFUOE+Fk+svm1Ecx5/ORBDRTBCXhBISXvbFYhmx1W01etOUURuetsr0qUvZ2qLqfr+uLiV90uiy0qIuDZmMhqwb");
            sb.Append("mw6byYJk/glvXH7LI/HC3M7L8/2cz+/kfHOQPJ3KkTld3yk2DdBiuDxn5I7FeJbubFAO0saLGju1UrUDaVs17so+9wO2hYN0HreSH3jfv8lBZJZavXW9Tg+22kGwDYzt");
            sb.Append("Is3WoQX9308gtjUCtjkEhaYeHYKQSFclJNJ7Ra9uXT0MixUtsD+xBLPdwwuIUtsQNPp7bk+7Pw2Cj5Ug+dEHeXht/f+CYWld/Vq1BuaLVfDHMAu/xq17Q6qGoHOutF3u");
            sb.Append("p9sy73Ts4MC3FsPrb62QpZEVXkh68isK7YoOmCkoh58aPWwaJnbayxV+l4agSrF395rWUe3oAJ5FBPl29Qm3Vcxpyi7grMgaTiZzCuF7Yxd81Yw4lMIC72vfiSFkk1XL");
            sb.Append("jfbSL5XAMb8C1CY/wktlR+NZKNjlKliub7ELWBzyrUU9ZkR7FFvLl4TLEqAbuYDOYmDEisAqe7PEiI7xuKvm85z+KCqsYlB0zJvPgiQDE3JMouOHyVFhtx7WyJXUxbb2");
            sb.Append("GTQuIcKY8XJ75DkDSpq4QLekQoI+GdhjmdtPBXERzYutM281CuoVGZaeQTVLS+ameOmnQ/GJ8CE+HroTkwy0vnhDtDEWYrRPgD3FOZWYsTkeln5VQBjd3V+MhvqyoJeW");
            sb.Append("AjiXexBJobgHR1LcWTj7ILo3CXxCmUAwl6arJRg1PJji4uaW2ebjwwJPz1wI8Wf0r9bU7ptUNZoqU7WmalW17x+S2k9kBEOwweHBLkVqjIpMKqtsuKDkMNCXeebhgQKZ");
            sb.Append("nKxGkIB7coEwgEdPdqXz6K6oXBBA7BEZwfgGMs9yccmhfFJhQ6QsNsOSkwsGNg84sXwjgjhd8w8uLu1EiuXwjSkGNvAt2cCUshjnSZe4IA0X5etW+t5tlKECr5vqyisT");
            sb.Append("eHWv9G6gOKoTdonSCO4fN/xVF/U+2t8AAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CrossSword_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CrossSword_Reset()
        {
            _CrossSword = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CrossSword_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CrossSword = null;
        #endregion
        #region Image DeadlockGraph
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku DeadlockGraph.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DeadlockGraph_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DeadlockGraph, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DeadlockGraph_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\DeadlockGraph.png
        /// </remarks>
        public static System.Drawing.Image DeadlockGraph_Cached
        {
            get
            {
                if (_DeadlockGraph == null) _DeadlockGraph = DeadlockGraph;
                return _DeadlockGraph;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku DeadlockGraph.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DeadlockGraph_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DeadlockGraph_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DeadlockGraph_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\DeadlockGraph.png
        /// </remarks>
        public static System.Drawing.Image DeadlockGraph { get { return _ImageCreateFrom(_DeadlockGraph_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru DeadlockGraph.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DeadlockGraph_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DeadlockGraph_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\DeadlockGraph.png
        /// </remarks>
        public static System.Drawing.Image DeadlockGraph_FromFile { get { return _ImageCreateFrom(_DeadlockGraph_string, "DeadlockGraph.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DeadlockGraph
        /// </summary>
        /// <returns></returns>
        private static string _DeadlockGraph_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1464);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAA7lJREFUOE9tkWtQVHUYxv9ajTkUguQlJcPRBUUBNUtQYAN1YQxEF1gGxybMxg9llLcSL2SFyIx4D8gjxG2UFmFBBElL");
            sb.Append("0yY00nIcdwYZucS4suyFhXMwzYP46zR96UPPzPvpned53988QheU1Za89sRwQpqkxqdI6vJkSY1dLan6VZK6JFFSFyVI6sIVkjovXlJDDJIavExSg5ZK6sxlxcPe/lld");
            sb.Append("Yt1H1UPlPfDFNchuge2XYfNF2HgBNpyDjAZIt4CxGhJPQVwl6L+B5WbQGesVkbTuWzmjxI0x30bqQRspx5ysPmTHlHOb9R83kfluKRszSsjY3IxxXzsr8u6RkGcjZr+b");
            sb.Append("KXG1sngz5aRsuebGI//FwNATnDesdJdUcCdzC93p72A3vU3vqjS64uOxpqfTWVuLx+XCfHUQn+jTsliSWiU335T5R39ab2KNCqE7ZQ3K1j0o2fkoWTkomdtR0t9DjjXQ");
            sb.Append("ufgN/iguwNLiwFuvfRCeYpabrY+RrW20xgfQYdCj5BxFySvCc6AAx8lqeivMOHZ+iWxIQlkQQdf8YOoLzbwQrQUsTD0tN916hOvyBW69FYe85TOUAyUou/dp5hrcm3bg");
            sb.Append("fH8z9ooq+pJMeIJCkCe9zMVVRibqyxSxINUin7k+yMCN69yPTUTJ2Iby6V7684/hbPoO99aduD7chr2+id5PdmF/VUeflx/XZk4nNCL3gQg11ct1vw7gONuAe044it88");
            sb.Append("FGMGzjPncFbV4PhKou/I1/SVVmKvPUO3htAmnqV1vA/Ri7IeimDTWdny20PuFxzGMT0YRUxCCdPjOlGOOyoOd1g4fYGh3J89n96CE9yJ0PP7KEGL3ziiInY8FIGmRtly");
            sb.Append("8zHu09V0BEz7NyAkEudh7aq3PzbxPJ3iOe6OHY/t4FFuawHXRwt+nDGFkMj9D8SMtGa55pdBHnnctBlX0u81mYHXYnFK5dg1pB6fV+jwncbdoPnYikq4vVhP6xiBJcHA");
            sb.Append("SzHVighIOy/X/OxmZOQx9sY62mcF0R+6GHdRGY7jpfQeKtKmUEMsxn68TNvPoWXuZE5pNY9d9oMsZq//aeiDSg+5dS4+r+qhcNMRrgbO5Z7GfW/O63QEzqN9ZhjtuhDu");
            sb.Append("TPXnfMBUcjfsZsXebp5JuDokfA3mTv+1V4bHGS+p3qsvqb4rG9XoqD1PcnTRIw2+k55e8vLi+xe9qJk44Wn2rIiR8CW7noyJbVJF/JVhEV3dI/5PMRPEqMK5YkLlDBFp");
            sb.Append("ni6MVTqRXBYsoo6Ficlr/MXo/3r+Bo7acUUH/s6TAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DeadlockGraph_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DeadlockGraph_Reset()
        {
            _DeadlockGraph = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DeadlockGraph_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DeadlockGraph = null;
        #endregion
        #region Image DialogError4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-error-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DialogError4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DialogError4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogError4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-error-4.png
        /// </remarks>
        public static System.Drawing.Image DialogError4_Cached
        {
            get
            {
                if (_DialogError4 == null) _DialogError4 = DialogError4;
                return _DialogError4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-error-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DialogError4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogError4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogError4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-error-4.png
        /// </remarks>
        public static System.Drawing.Image DialogError4 { get { return _ImageCreateFrom(_DialogError4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru dialog-error-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogError4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogError4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-error-4.png
        /// </remarks>
        public static System.Drawing.Image DialogError4_FromFile { get { return _ImageCreateFrom(_DialogError4_string, "dialog-error-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DialogError4
        /// </summary>
        /// <returns></returns>
        private static string _DialogError4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1528);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("VUlEQVQ4y6WSz0tUYRSGn/Pd795xmiatRdAomWEghX+AbXPlskVJixbCaO4D6R+I1iKiUKt2thBXEgglBCVRtBApiH6ASCPNOHPvOHrvd7/7tRizwTZB7/qc55z3vEec");
            sb.Append("c/yPNMCz0dGp7sHBORUEnpfLoXwf5fuI5x0XOmvJjCEzBhNFtra5OT3+6tVjDVAcGpq7MjKiu33/n6ZWm019emBgEWgDtt+/V1eHh4n29/8qFuCkyVyhwKfVVa7PzKAA");
            sb.Append("vr5+TbO+x36jgQ0Cestl0nyeJAyJwxAplbgwMUEcxxw0GrTqe3xeXwdoA4xAXKuShCGXJifRxSID5TKHnkdWKnHx9m2Cnh76p6ZI6nVMfQ8jHUc0QFKrohLLztoafWNj");
            sb.Append("KK259uBB+5AiOOf4trSEbTQgbmE6U0gBW/0JVthdWCAJQy6Pj6O0bifgHFuPHiEbG4gI+5UmaScgEdh++YKiztMdBOwYw4WxMbyuLgCSWo3m8jKFSoW93V0i7UiOLKjf");
            sb.Append("G+jUoKKIrK+Pofl5DtKUqFKh2WiQBAH9i4u0tOaMCHklxxv8AQjktObS7CxZoUBSq/H25k3e3LtHGseo3l7OPXxIzjl84QRA2oFn1vJjcpL4yxe+37nDjQ8fGF1Z4eP0");
            sb.Append("NK2tLQ7v3ycVwclRDyDOOW5psePFQOUPFedEKCjF+TQl7xyecyQiVH0fk2VURWjmLE/COFtKndeO0Ymp5G2uJBCKYMWRIviiUIAFjLMcAC2XEZ5NyZpijlPo9YO77+Lk");
            sb.Append("6fPI6s4X7lTnO6tIzMCpYOLYwv/oFyCODyf2jBu2AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAyOjM0LTA3OjAwtueOEgAAACV0RVh0ZGF0ZTpjcmVh");
            sb.Append("dGUAMjAxMC0wMi0yMFQyMzoyNjoyNC0wNzowMC7DUNYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MjQ6NDYtMDc6MDCPDs7OAAAAZ3RFWHRMaWNlbnNl");
            sb.Append("AGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEv");
            sb.Append("W488YwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0wMy0xOVQxMDo1Mjo1MS0wNjowMH9o/QYAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RF");
            sb.Append("WHRTb3VyY2UAT3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DialogError4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DialogError4_Reset()
        {
            _DialogError4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DialogError4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DialogError4 = null;
        #endregion
        #region Image Dialoginformation3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-information-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Dialoginformation3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Dialoginformation3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Dialoginformation3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information-3.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation3_Cached
		{
			get
			{
				if (_Dialoginformation3 == null) _Dialoginformation3 = Dialoginformation3;
				return _Dialoginformation3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-information-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Dialoginformation3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialoginformation3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialoginformation3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information-3.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation3 { get { return _ImageCreateFrom(_Dialoginformation3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-information-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialoginformation3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialoginformation3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information-3.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation3_FromFile { get { return _ImageCreateFrom(_Dialoginformation3_string, "dialog-information-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Dialoginformation3
		/// </summary>
		/// <returns></returns>
		private static string _Dialoginformation3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1644);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("rElEQVQ4y32T32scVRzFP/fOvTu7m01iYmmC2qVERIQYU/IDUelDQQn62AdBQqG0KtqWRiUipWokAR+MraAQ6kNfxAf9AwxifFFiIZI8tJSkwaY06IO7ZtbZ7M7MzszO");
			sb.Append("9WHiyobWL1y4cM85l+85368wxrCvBKABvbR256CUQhwbPlwGIiAEkjbwPgHr3OeLY1sl79PeB7oGD/V3dXZktShXfM+pepsDB/NTM5PPLgPxvQTkU6cWLli5zounXxyx");
			sb.Append("B/q7sbWFMRDGCSXX4/vVu7HjVi4vzh6/8K9IS+DAS3PvPNj/8Px7rxzFqUW49Yi8bQHgNZp05jQP9dp8/fMmt7e2P7x19dVZwAhjDGLs/OOqt2/t3cmJvB8ajIFCTvH+");
			sb.Append("y08CMPvNDWp+jBDQndd8/O1Pvmo4I7XvPliXACg9d/TIE/myG+LWQ6peiBfEWFJgSYEXxFS99O33HY/nBgdy9YBZALXn+6iwbP6uBy03d/0GZxeuYYzBqUdtMWW1BqlG");
			sb.Append("AJQYerOHQr4opGDXD1ugxZkXWveJj5YQhlaCthaAKYqhMz2KZlZgEqq1CKX30rEyPHPxB36Zex6AWlORJE3c3QZutUqp4kMzgkhIZW5ecsTTb5dXNu72CZ1BZwuojg6U");
			sb.Append("0lQqFQCWt31IEohCCBOII4gaZbP+xU7qQWJ+Iw76TLZAKDOEiQ2x/K9pZYOQ6TEJBC5EwW2AFCXFNLVSjLBSsLZxLo23+M4nR8DOg7bTSXe2Y2C6bZDE+NQVct2v8cgw");
			sb.Append("FA6AzqYklYU4SHt2/4Sta+C7X5qVy6+3CwghGJu6iqVOIIclj3VD9Gj6a+YObPyFjFeTJI6+4tfPTpo94v5lQoy+dczOqSsoqxg24owBdEcmUoY/Qj88HS/P//h/29hW");
			sb.Append("cuiNogHM9YXt+2H+AZcILF7Acqn9AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAyOjM0LTA3OjAwtueOEgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0w");
			sb.Append("Mi0yMFQyMzoyNjoyNC0wNzowMC7DUNYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MjQ6NDYtMDc6MDCPDs7OAAAAZ3RFWHRMaWNlbnNlAGh0dHA6Ly9j");
			sb.Append("cmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvW488YwAAACV0");
			sb.Append("RVh0bW9kaWZ5LWRhdGUAMjAwOS0wMy0xOVQxMDo1Mjo1MS0wNjowMH9o/QYAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRTb3VyY2UA");
			sb.Append("T3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Dialoginformation3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Dialoginformation3_Reset()
		{
			_Dialoginformation3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Dialoginformation3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Dialoginformation3 = null;
		#endregion
		#region Image Dialoginformation
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-information.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Dialoginformation_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Dialoginformation, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Dialoginformation_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation_Cached
		{
			get
			{
				if (_Dialoginformation == null) _Dialoginformation = Dialoginformation;
				return _Dialoginformation;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-information.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Dialoginformation_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialoginformation_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialoginformation_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation { get { return _ImageCreateFrom(_Dialoginformation_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-information.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialoginformation_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialoginformation_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-information.png
		/// </remarks>
		public static System.Drawing.Image Dialoginformation_FromFile { get { return _ImageCreateFrom(_Dialoginformation_string, "dialog-information.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Dialoginformation
		/// </summary>
		/// <returns></returns>
		private static string _Dialoginformation_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1508);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("0UlEQVQ4y2WTT2hcVRTGf+e+NzPJJMSi0tZKxNrBSjFQZaALMaQKdaFk4zabQCNKFy5ipW46XQpKQHAXxEADrgQR3EdxJRHLgKBGrWmcpDGTtMkwb967/46LmcYGPzib");
			sb.Append("w3d/fIdzj6gqD6s+t1wTkdlSmkyFGCcAksQ0vQsrUXVpdXHm94f98gBQn1s2iTHz5XJyffLFp6vjx8fMycdHEeDubpc72/vh2x9vF9aFRoy6sLo4Ew8B9bllk6bJd6ef");
			sb.Append("fPT89OTZkdwrBz2HKoiAAGPVMpVE+Wrll2x96/5P3ofJ1cWZaACMkfmnnjh2/o2Xnxv5cydjbatDJ3O881qNty/V6PQ8a1sd/mr3mL54rjp+4pEXjJF5AFO/fLNWSsz1");
			sb.Append("i/VnRn7dPGCvY7Eu4kI8nNOGiHWB3Y5lbbPDKxdq1VJiGvXLN2upqs6eO3Ni+F7X0r7fQ4xgBArnaXzRBBGy3AGgCnnuqCTC87WTQ6s/b8ymoFNjo5Vkey8jtw4jgogg");
			sb.Append("CEXhjmxIVVFV/rmnjI1UEtCpNHg/MVwpsdHO8FEPHy+8dYE0MRQu8P5nP/QBA4j3nvHHqgTvJ0wMkV5uyXP3XxWWK59+jwDD5YS8cP0a+IrckeWWGCKpamze3Tl4STXp");
			sb.Append("Rz4cAaJGDEKe28MEqJJUSmzv7KMamyZ4v7Kzd+ANkbzo0/PckheWOFhEP4Ed9B2GyM7ugQ/er5gYwlKr1bbOOYixbywcyx9cQgRciHx+9dXBaA5iwDnH3622jSEsiary");
			sb.Append("7JufvFcdrtw4der4yH7XYl1AhP+plCYcG63Qam13s15x47cv3/3YAGjwC1k3u7VxZ7NblshQKpgYicETg8dov1eSwPp6q5t1s1sa/MKRYzoz/ZEBmTeGRrU6PFQql5Ny");
			sb.Append("Ke3/ROdx1vlullmN2gAW/vj6ajwCeKDTr39YA2ZFZEpVJwBEpKmqK8DS7W+uHTnnfwG1B7b5HI6TOAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNDo0");
			sb.Append("MC0wNzowMBgWrX8AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTI6NDctMDc6MDC9hdM8AAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1v");
			sb.Append("bnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBHTk9NRS1Db2xvcnOqmUTi");
			sb.Append("AAAAMXRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9nbm9tZS1jb2xvcnMvUB216wAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Dialoginformation_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Dialoginformation_Reset()
		{
			_Dialoginformation = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Dialoginformation_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Dialoginformation = null;
		#endregion
        #region Image DialogNo2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-no-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DialogNo2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DialogNo2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogNo2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-no-2.png
        /// </remarks>
        public static System.Drawing.Image DialogNo2_Cached
        {
            get
            {
                if (_DialogNo2 == null) _DialogNo2 = DialogNo2;
                return _DialogNo2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-no-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DialogNo2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogNo2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogNo2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-no-2.png
        /// </remarks>
        public static System.Drawing.Image DialogNo2 { get { return _ImageCreateFrom(_DialogNo2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru dialog-no-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogNo2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogNo2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-no-2.png
        /// </remarks>
        public static System.Drawing.Image DialogNo2_FromFile { get { return _ImageCreateFrom(_DialogNo2_string, "dialog-no-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DialogNo2
        /// </summary>
        /// <returns></returns>
        private static string _DialogNo2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1612);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAArFJREFUOMt1k09Ik3EYxz+by82XqFcNdYVkMlqhsUUgDSEGQVgKSbegQ8Tw4CXZofDkoTp16RCSEdVF6hTUoYQmZOUqIx2kA8P+qFT7617/");
            sb.Append("zbntfZ8O09eKeuDL7zn8vt/ny/f3eyz8VV2wt7K6uqfx0CHvLpfLq1itzE1ORr5Eo5GMpt24DbP8r3pra/tCly/LajQqomkiCwsiqZRIMimr795JKBCQXlXt+51Tttlc");
            sb.Append("dbvvBW7e7PGePMk2XQdNg0wG0mlIpdhWKNDY3Mx+l8tve/OmIZzPPzYFeuvq+gLXr/fU79sHi4slZDKwsACpFCSTEIvBz5/s0HVcTqfXMT7OKIyUdcHOtrNnHx5panKw");
            sb.Append("skLk5UtiqsrU0BCNZWWQSDA8Pk7B54OREZSZGewTE6wmEl7gjg04f+zwYZVwGMrLqWhtxX3iBFm/n+HubtB1fAMDKKpKeHqao8EgRcPgAKiVcM520OPxK4lEybbFgvL0");
            sb.Append("KdmWFhRVxdffD4CiqsxHIijXrqEbBkVgO7AHjlsVh0MlHjdDq4/FSAeDZDUNRVVNcrq9HY+mUQSKQAEQ2G3FMGB5uSSwgU/x+B/PW93QQNrpRC8UWAfyWwJYk4nEN9bX");
            sb.Append("S6lrGsMi+AYHzcmbTnyhEKMeDzkgB6wDyzBjnZudfTGfz5vTK9rbt2x3dJBuazNFrJ2dpkCshNcAPGht/Sput4jTKXNVVTIaDMpEba0YdrsULRaZ8Xhk6OJFeQsyBTIG");
            sb.Append("cgW+b2QJXXB6tL5exOEQsdvFsNmkaLFIDmQRJA7yDSQK8h7kPsgZuGD+xA8wnVtaStcUi6dqdJ28YZADssDaxpkFVoEo8AQuPYJbgJi78BHG1mBsHo4BO5W/yNPAK/gx");
            sb.Append("DIEncBfQASz/WMryTmjZDp1VsF+ANHxOwrPnEAZWfr/8C9WmVQ14ikIGAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwJK7h4AAAACV0");
            sb.Append("RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTg6MzQtMDc6MDCRilBxAAAA");
            sb.Append("NXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6");
            sb.Append("MDg6NDEtMDc6MDB7H5fUAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwA");
            sb.Append("aHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS92PbRSAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DialogNo2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DialogNo2_Reset()
        {
            _DialogNo2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DialogNo2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DialogNo2 = null;
        #endregion
        #region Image DialogOkApply3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-apply-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu DialogOkApply3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property DialogOkApply3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogOkApply3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3_Cached
		{
			get
			{
				if (_DialogOkApply3 == null) _DialogOkApply3 = DialogOkApply3;
				return _DialogOkApply3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-apply-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image DialogOkApply3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogOkApply3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogOkApply3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3 { get { return _ImageCreateFrom(_DialogOkApply3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-ok-apply-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogOkApply3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogOkApply3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3_FromFile { get { return _ImageCreateFrom(_DialogOkApply3_string, "dialog-ok-apply-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru DialogOkApply3
		/// </summary>
		/// <returns></returns>
		private static string _DialogOkApply3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1596);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAqVJREFUOMulk0tIlFEcxc+993uN83AUnWmiB46VNoENCSJTi4LsIQZFkUgFSbkIV22yTc9Vi6KVQQ8QAoOEhAIrpyJc9GKCMs0IraaXMtOo");
			sb.Append("5UzOzHe/794WtqigF579OX84/98hUkrMRsR5LABpA0regModUHMOmMSGqeYAasJSOUzdhKR5EJVDaBwQ5lJvwHUBKg3R/zonAXC+u6J8brRpZW3Eq3rEPwdIKUsFxfn1");
			sb.Append("tVUdhzaumdc/NCbiI8lmRUKWSYlpAInfOCEsUeP0OTr2rA2FNleW48StJ7gfi+8jTnpNKS5xPze5eJl+bzVowMefvEKqOdtqWbCk6OTBhmrHKr8Xbb1PEO2LH6G6cg5E");
			sb.Append("gHqYM92wuizsLNIuc0sUz1QLCFtW2gYurVsTbG/fvsER8Qdw7PYQonfGTmtSOQ468z06OpI9Owc+tG6JrCQF6BYCxOKizu1Xoi1bw9uO1q2H3+XCqb5nuH4j0aVz1oYf");
			sb.Append("mmNaODA6keF792+sV3S3WPjgxbuWYMjdfKAxUlIfrEZOpNHx6Cm6ryRuwrR3QbeylmLC1vKQugXmDZd9Hp/Izi+dZ1Q3hlcRI5D1bK2pUkOF5ZiwErg6OICrXal+MkWa");
			sb.Append("VJWmmK1AtTVo3AEtXwDmXR6UdkblU2Ryx/IKPwn7FoFJhkk7ibuvhtDd+SUux8kmTSdx1dKgWQaMvAvGdCEcGS9YceUyqJbxPpMWkcLFX4MuXcGUTCL24TV6OrMp/lHZ");
			sb.Append("TA0+KJn4zq6EJBKSCkgqQA1Th0NoeTLq6YnFJjFGRtCffIPeTjNjDhfsZAyxPwFGma2D2ToMoV/89Nj59uHwGO51MTM74G1lDL1/I5TNWbICVDJQQrJ02vClhl21uRfu");
			sb.Append("w2DWGalZEIxDKhxgYgaQX9c42zl/AznZIS3sjy1VAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwJK7h4AAAACV0RVh0ZGF0ZTpjcmVh");
			sb.Append("dGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTg6NDAtMDc6MDBvAH17AAAANXRFWHRMaWNlbnNl");
			sb.Append("AGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDEtMDc6MDB7");
			sb.Append("H5fUAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5p");
			sb.Append("Y29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS92PbRSAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property DialogOkApply3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void DialogOkApply3_Reset()
		{
			_DialogOkApply3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití DialogOkApply3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _DialogOkApply3 = null;
		#endregion
        #region Image DialogCancel3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu DialogCancel3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property DialogCancel3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogCancel3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3_Cached
		{
			get
			{
				if (_DialogCancel3 == null) _DialogCancel3 = DialogCancel3;
				return _DialogCancel3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image DialogCancel3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3 { get { return _ImageCreateFrom(_DialogCancel3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-cancel-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3_FromFile { get { return _ImageCreateFrom(_DialogCancel3_string, "dialog-cancel-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru DialogCancel3
		/// </summary>
		/// <returns></returns>
		private static string _DialogCancel3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1896);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAA4RJREFUOMst0t1rW2UAx/Hf8zznPEnOSfqSZG1ausRpsdnG6OzK2kkdRdzsyxDZGGiZE8SC5GKdeuFfsoHohWCpgwmyq4E3w0nRlmhb09HB");
			sb.Append("YpO2SReTpjk5Nk2TPC9e2D/gc/X9kq96elBvtWLxzs75oNZvpA4PP9VKPeBKwdQaVCkQpSClBAOm493dPzSU+ntrc3PGR+kGG/X7Y1G/f/7DkZGxi6dP88N0ejqvVJZo");
			sb.Append("nTIAEK2htYZW6tpgMLgwPTvbFhscjJTS6dGq4yyyW6dO/XxrePhSaG4OuHkTr+Zyplpbm8xTukmBdaI1IOXUBY9n4e2ZmTbzzh14BgYQCwR6K4XCuBHyes8FQyHAtgHX");
			sb.Append("hZFI4PLBgU8+fPjNim03IaV7TogHYzduBDy3bwP7+4CU8MdiCHZ1vc4GtM40HGfitVyOk0gEIATG0BB6X77kzbW168Fm84Pxq1etQCIBSAk4DvTyMpLz842/nj79nI15");
			sb.Append("PKlt183QUmkqWiyaNBIBpIRx/jxC+Tzt6+42OhIJkGOskkmsPnokfl9c/EILcZ9d9vuhW6313NFRVhQKU9HdXYOFwyBawxuPwxocBNUaulyGXFpC8vFjsby6eldJec8g");
			sb.Append("BOwt2wYBACFShUbjWaNUut5TLjMeDoNQCiIEdLWK+tIS/njyRK6k058opb5lAAghMNprNSiloCiF5txRlqX+TSZxUCiARiIAAFmrAa4LaRiKAA4HwAGYWoNdMU1IIaC9");
			sb.Append("3msXTp788c1q1a6Vy6iWSihnMqhmMmg5DijniPb1MaOz8/1SsZjF8SfsHcagOJ8ajccXxvb3247yeTQBSAAWIfBxDm3bYD4fCIBoLGaaJ05M/pPPb1Kt19kV235v6OzZ");
			sb.Append("hfFKpa2ZyeDoGHtNE7sej6oyJrs9HqpNE4RzUKXQ199vIhic2N/ZyRnxM2fm363XA40XL9AEQAH4LQtpn6+xVq9/plutqiHl9/1ery0JgQDQ2t3F8PCwrSj9mjZqte0D");
			sb.Append("zkFNEwSA1dGBrWBQ/Hl4+KVU6jsN/PSsUpndrtXqPtsG1RqUcxw1m6hXKgV20XV/Kfr9I690dfUGGEOqvV0ki8W7Uoh7jLH/E0u5XnLdrGlZk33RqKnDYfy2uPg8t7Ly");
			sb.Append("EZvkvOTs7f164PNd2rOsUGpnZ04IcZ9SCkIIoDWYUoDWKbdSyQpKJ7az2ezWxsbHjJCl/wB757imf5fIowAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjow");
			sb.Append("ODo0MS0wNzowMCSu4eAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5");
			sb.Append("OjE4OjQwLTA3OjAwbwB9ewAAADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnkt");
			sb.Append("ZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwex+X1AAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXx");
			sb.Append("AAAANHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuaWNvbi1raW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property DialogCancel3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void DialogCancel3_Reset()
		{
			_DialogCancel3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití DialogCancel3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _DialogCancel3 = null;
		#endregion
		#region Image Documentnew5
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-new-5.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentnew5_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentnew5, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentnew5_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5_Cached
		{
			get
			{
				if (_Documentnew5 == null) _Documentnew5 = Documentnew5;
				return _Documentnew5;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-new-5.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentnew5_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentnew5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentnew5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5 { get { return _ImageCreateFrom(_Documentnew5_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-new-5.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentnew5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentnew5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5_FromFile { get { return _ImageCreateFrom(_Documentnew5_string, "document-new-5.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentnew5
		/// </summary>
		/// <returns></returns>
		private static string _Documentnew5_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1460);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAj1JREFUOMuVk79rU1EUxz/vvZvkJSbVFtGKWgpVFBVRsItaxEGQInXSTXB2EsTFxUHHgv4BDopDi4MiHRw6iCCIBWmLtmioGGoqbSUlNnl9");
			sb.Append("P+89DnnSKOngge89ZznfHweuJSKcvP5w4srwmbMWGBE6lqSP7dhWmMTW2PPXL8vz5RsKYPj8qXN3rg6W+I+qVGsXy99W+xSAGAmAjgQiYAAjYAw4DmCBiIQ4tlGwtW/z");
			sb.Append("Z9mkswAGLAdEBERQW1k0KcSkvW0OgfUAiOlMIG2qqRBaIEwAGzYALwSSDgSmPXOaTGvwNUQZcGwwAVgIWP9EMLJpVdIDJkCUgyQG//NHlJNBDhwmyBQFVZS/CEQ2lXW6");
			sb.Append("7HkbrC/MwvZ+7OlHUHDxeu5yYmUqe3TxlVIAltWWXSAWiBIwOfB+VpH5MaJoD3lrDfHzuNP3ubnvaXf9VzWrALy4RRBriDTEBrQBE4LkemiYfrqj95R6I7LuD4Jwlsfv");
			sb.Append("jjWPJ/VtCqDmgwaSdNkIiILG0iLe1DilfITbVWT3yEFwKqxOfGLoUmPnrr7iqE3bsRLTQpzCOFm0WyAIAoy/gfg++CE6MTRqbqzrpqkAMsqxcrQy27plPzGQ29tLtniN");
			sb.Append("+O0Tcs0lll58IO/6FHYolivUw/GNWwpgZa1hz6wKsRYiIy1HGnAd1heWKX2vMMdpDnTPgClQqe1nsGe0y8s0bQXwZnLy3sjc18tYaEk/hlgAFmI0rBUkUZ48GCgPxHbW");
			sb.Append("uV09Uh6aOfTsQtL48htq3EnkMk3ykAAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjowODo0MS0wNzowMCSu4eAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAt");
			sb.Append("MDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjE4OjQwLTA3OjAwbwB9ewAAADV0RVh0TGljZW5zZQBodHRwOi8v");
			sb.Append("Y3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwex+X1AAAABl0");
			sb.Append("RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXxAAAANHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuaWNvbi1raW5n");
			sb.Append("LmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentnew5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentnew5_Reset()
		{
			_Documentnew5 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentnew5_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentnew5 = null;
		#endregion
		#region Image Documentopen4
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-4.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentopen4_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentopen4, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentopen4_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4_Cached
		{
			get
			{
				if (_Documentopen4 == null) _Documentopen4 = Documentopen4;
				return _Documentopen4;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-4.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentopen4_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen4_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen4_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4 { get { return _ImageCreateFrom(_Documentopen4_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-open-4.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen4_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen4_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4_FromFile { get { return _ImageCreateFrom(_Documentopen4_string, "document-open-4.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentopen4
		/// </summary>
		/// <returns></returns>
		private static string _Documentopen4_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1480);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAEnSAABJ0gGoRYr4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("TklEQVQ4y62SPW8TQRCG373dcxyT+MBSYiEhd5CCD6WkAdGmp6CloUM6RMU/QVSIijqijayIAiiwFClEQTIEEmLHIfb5bG7vbr+GwmeToEg0vNKupnmemV0NQ5EwDBHH");
			sb.Append("8dWVlZXblUrFIyLGOT/3AOD9fn8nDMNNEYbharVabQCwQRDcXVtbexwEAbfWgjEGAGCTTGsIIUSr1XoOYFM0Go2n9Xr9gTHGaa1ZuVz2h8Mhsiw7LQAA+L6ParWKUqkE");
			sb.Append("Y4wkIgjO+YgxJrTW8DwPaZoiiiIYY2bgVMI5h1IKQgj0er29ZrMJoZQ6IiLSWrNarYYoGmA8HgNgmPIMDGCTyloDKeXgYP/7x6NuFyLP8x4RGWOMz7iPb4d9WGen2LQ9");
			sb.Append("OOfgnodYWuz/6Oy+6y2N5dyVyyLLsmMppfKF8PtZCcfmEoTgOB0CwBwABxABqrZ0/c69ufXuz7gt8jzvJ0mSLy8vXxiwecwtXoQDA9EEJZoICChqgkcIGCgQgrdEmqZR");
			sb.Append("nufJwsJirfvLh7IERw4oQBTQRAg4ImhDYOTMIE7fCillrLUei1IZmROwjkB0qnNhcQQ4RzB2YjJKnZwMkw9CKZVImcSfPu8hrtyA7xGsdXBTyewJNJvKY8AoyXf2O4Nd");
			sb.Append("MRqNUpXn0fbXHuav3UTJM6BiXppdZ2OtxWAom8+e3I/F+411Vw4eRap+C06BpE7Pfv9fDgbGkiQ5PPiyu/H6TQXiOIFpH8YvmO5seZ0eP6fh2TCPsmTUbm++2l59+PLP");
			sb.Append("rgDgALx/8cVAxVb8h/wGVjZeGddC2OMAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTItMDhUMTM6MTY6MDQtMDc6MDAdDpNuAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEw");
			sb.Append("LTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0yNlQxNzo1NDoxNi0wNzowMCdfmx4AAAAydEVYdExpY2Vuc2UAaHR0cDov");
			sb.Append("L2VuLndpa2lwZWRpYS5vcmcvd2lraS9QdWJsaWNfZG9tYWluP/3qzwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMi0wOFQxMzoxNjowNC0wNzowMEK/5VoAAAAZdEVY");
			sb.Append("dFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAGXRFWHRTb3VyY2UAVGFuZ28gSWNvbiBMaWJyYXJ5VM/tggAAADp0RVh0U291cmNlX1VSTABodHRwOi8vdGFu");
			sb.Append("Z28uZnJlZWRlc2t0b3Aub3JnL1RhbmdvX0ljb25fTGlicmFyebzIrdYAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentopen4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentopen4_Reset()
		{
			_Documentopen4 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentopen4_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentopen4 = null;
		#endregion
		#region Image Documentopen5
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-5.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentopen5_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentopen5, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentopen5_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5_Cached
		{
			get
			{
				if (_Documentopen5 == null) _Documentopen5 = Documentopen5;
				return _Documentopen5;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-5.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentopen5_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5 { get { return _ImageCreateFrom(_Documentopen5_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-open-5.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5_FromFile { get { return _ImageCreateFrom(_Documentopen5_string, "document-open-5.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentopen5
		/// </summary>
		/// <returns></returns>
		private static string _Documentopen5_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1372);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAfxJREFUOMuVkc1LVFEYxn/n3qMjMzY2OYs0V61q10JctCiSSHATrfrYtcv+A6Ntf0HBFERQMCK0SKEWFhEEgURCVhQUgol92Hyqc2e8c89H");
			sb.Append("i3OHES/08cJZnPPy/M7zvK+w1vKnOnni+NL4+Jl80Gqp3e/ZfdneZ0+fTAtOz5/Fk3MJZXV5ijfXHhZnZkuXLp4XgQYvbhkg48Po6LE1iSfn7MJkQi8mKHD06qEflXZr");
			sb.Append("tUG6XgIvJoQGDo9ApAklwOLXpHW7MImY4Pp6rcbbz9AMwO8AdqDpQ6gQHkA1cKcSQLUJ5QAef3SQXL9PNgO+dRE8QPowkAIBSIBfDfi0AfcXk06u5DwODoLU3QhRBEMH");
			sb.Append("wForJcDGlhP/vJEE3LztMTIAXhuEcG9aQ74HhCXlANuu8WIl/sGAMtDWkO5LETVqHBnOJeA6MhkXIQZUWy6XMhBpBygUi9y5dxfwsECwqejPSkqbEatfPlQkQKkRAwK3");
			sb.Append("Y2OgbSBScG56llBBqN391cx3xi4Mc+tRC96n5yVAOXZQaYIFtHExIg2hck4i3b1vh90YEtzqOtuw1kGUgXYs1taJlXGAxl7AVhN6emMHFox1LpTpzkOZeMB6L6C6PFV9");
			sb.Append("R4GhUzz4xt9rTbHyfB1eXl4C6gIYBMbis/8fEJ2qA68F4MfCPND3H4AdoPwbjjv0LDm2vjoAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDEtMDc6");
			sb.Append("MDAkruHgAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToxODozOC0w");
			sb.Append("NzowMFYqOgUAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAw");
			sb.Append("OS0xMS0xNVQxNjowODo0MS0wNzowMHsfl9QAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAADXRFWHRTb3VyY2UATnV2b2xhrE818QAAADR0RVh0");
			sb.Append("U291cmNlX1VSTABodHRwOi8vd3d3Lmljb24ta2luZy5jb20vcHJvamVjdHMvbnV2b2xhL3Y9tFIAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentopen5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentopen5_Reset()
		{
			_Documentopen5 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentopen5_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentopen5 = null;
		#endregion
		#region Image Documentpreview
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-preview.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentpreview_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentpreview, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentpreview_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview_Cached
		{
			get
			{
				if (_Documentpreview == null) _Documentpreview = Documentpreview;
				return _Documentpreview;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-preview.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentpreview_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentpreview_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentpreview_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview { get { return _ImageCreateFrom(_Documentpreview_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-preview.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentpreview_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentpreview_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview_FromFile { get { return _ImageCreateFrom(_Documentpreview_string, "document-preview.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentpreview
		/// </summary>
		/// <returns></returns>
		private static string _Documentpreview_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1652);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("sklEQVQ4y22TTUhUaxjHf+97zvFMx5nxYxorKhGyhRBC4IBNUtnm3r7mplzcJIK5jDZRywr73EjRojYFrQWlaJEtLxf60CKKey26V7mhM5U46DTkcY4z5zwtzIujPfDy");
			sb.Append("rt7f8/s/7/sqoBpoOnzkSGPqWOpUdi6/2dRSMEzj74sXzt9yXdenvAR4LyI5AAXsGRl58uz1+yxDf3yhJhYlP6mIbPf4fV+Eo4faqaqqQikFgNaaSDicFJHnAOb+/Qea");
			sb.Append("Rt9Oc//xDL2nf2PrzjrCtsXHqSyPHr7ACf1JZ0cK9aO9KttAt7W1nR0ZW+D4ycNs2VFHEAkxb1vE62P8cqKdV1OKT5kM2jAwDAOtdVkeMxKN1rpLiti2auywRdgx8VEo");
			sb.Append("28YXqNy8iQ///EtDQ8Ny67UAr1Ao1URjOOEKKh2TKgMsDV6gCaIhtsQdImGFYRjLAKXKAHo6Pf12x9YKRMA2NBFLE7U0labGNBQbjQLNzc0opdYdBtD37t69vrcpoJSe");
			sb.Append("YdEHrSBsagKlsD+nqcZFa/0/YC3EBIKD7fsYfTFK4fUiU9s28VkHMD+Hl03jOA7zuRz5fJ76+vr1BgB18Tip1DESjbVEZv8j9i1LclcjnR0dZGdnuXP7NiHHYWJiYsVA");
			sb.Append("VkOS3xYWxHVd8TxPlpaWpFgsSqlUEt/3JQgCGRoakt7eXplOZ+Tly1cBkBARRGTZYHW+tQugpaWFRCLB1SuX2eBsUMPDw2e6urqMlReVdF33qdZ63bCUUvi+z9jYGK2t");
			sb.Append("rZw5ey4Tq6mOJ5PJCsuyng4ODv6qAeEn17NSnudhh0L0X7v+7tbNG83j4+Odk5OTbiaT2dvT0/MAoNVdXAw8z5NisViWX0Qkl/saXOi/9BxwVnJ3d3e3DQwM/NXX19eg");
			sb.Append("ABvYveqDrNYRoAS8EZHizwy/A0PFF/wGi5MoAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAyOjM0LTA3OjAwtueOEgAAACV0RVh0ZGF0ZTpjcmVhdGUA");
			sb.Append("MjAxMC0wMS0xMVQwOToyNDozOC0wNzowMKSpBDYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MjQ6MzgtMDc6MDDV9LyKAAAAZ3RFWHRMaWNlbnNlAGh0");
			sb.Append("dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvW488");
			sb.Append("YwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0wMy0xOVQxMDo1Mjo1MC0wNjowMNkf9rIAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRT");
			sb.Append("b3VyY2UAT3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentpreview_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentpreview_Reset()
		{
			_Documentpreview = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentpreview_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentpreview = null;
		#endregion
		#region Image Documentproperties3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-properties-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentproperties3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentproperties3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentproperties3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3_Cached
		{
			get
			{
				if (_Documentproperties3 == null) _Documentproperties3 = Documentproperties3;
				return _Documentproperties3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-properties-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentproperties3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentproperties3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentproperties3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3 { get { return _ImageCreateFrom(_Documentproperties3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-properties-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentproperties3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentproperties3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3_FromFile { get { return _ImageCreateFrom(_Documentproperties3_string, "document-properties-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentproperties3
		/// </summary>
		/// <returns></returns>
		private static string _Documentproperties3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1088);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAAAmJLR0QAAKqNIzIAAAAJcEhZcwAASdIAAEnSAahFivgAAAAJdnBBZwAAABAAAAAQAFzGrcMAAAEtSURB");
			sb.Append("VCjPTdHNbhNBEATgr2fH+C/g8HPPCSIQPBXPxCXPwXMgcYuCEAIpyJAoUQLG7No7k8NuEF2XVquqWt0V72zj8OlioXba//A3Ntvry1nNU+nJm5PDV/qiqMo90vdP799O");
			sb.Append("LjLNfPl6/pyiCgHCRJlOls1F3itqJWy1QgLJY1FrJe/1qsSo3khmY18VqdMpijSqz310jsQgHQghJCE7Er7ZalD00k6LLLlxJTzQ2CujQy93dqPD3hfXdnZWFjL2YiD0");
			sb.Append("eo1n1n4osuqrQ8PhubMbr0iOrFCtbay1GuROq2rA3FISDlyNC8idrhaQVUnSOHZr49cwDbdNjSQ8FBpJksz8cZm6tJBP4nh5+rNfKcP3/qWRPq/Pph+EmB28fLF4VN1X");
			sb.Append("HeNqb07PNr/vAPWlhbyTRcCkAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTEyLTA4VDEzOjE2OjA0LTA3OjAwHQ6TbgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0y");
			sb.Append("MFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMjZUMTc6NTQ6MTYtMDc6MDAnX5seAAAAMnRFWHRMaWNlbnNlAGh0dHA6Ly9lbi53");
			sb.Append("aWtpcGVkaWEub3JnL3dpa2kvUHVibGljX2RvbWFpbj/96s8AAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTItMDhUMTM6MTY6MDQtMDc6MDBCv+VaAAAAGXRFWHRTb2Z0");
			sb.Append("d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABl0RVh0U291cmNlAFRhbmdvIEljb24gTGlicmFyeVTP7YIAAAA6dEVYdFNvdXJjZV9VUkwAaHR0cDovL3RhbmdvLmZy");
			sb.Append("ZWVkZXNrdG9wLm9yZy9UYW5nb19JY29uX0xpYnJhcnm8yK3WAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentproperties3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentproperties3_Reset()
		{
			_Documentproperties3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentproperties3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentproperties3 = null;
		#endregion
		#region Image Documentsave3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentsave3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentsave3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentsave3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3_Cached
		{
			get
			{
				if (_Documentsave3 == null) _Documentsave3 = Documentsave3;
				return _Documentsave3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentsave3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsave3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsave3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3 { get { return _ImageCreateFrom(_Documentsave3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-save-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsave3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsave3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3_FromFile { get { return _ImageCreateFrom(_Documentsave3_string, "document-save-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentsave3
		/// </summary>
		/// <returns></returns>
		private static string _Documentsave3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1328);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
			sb.Append("wUlEQVQ4y6WTPWgUURDHf+8leHvdqVckKWMrYmchiB9cl6AQsRJbS7WwkGAnGLRW7G1U7ExhobWdAcuDA1N4HhE0u7cf2d038yx2PXc9CyUD817x+P/nNzM8473nMLEI");
			sb.Append("sL629uPgIO/dunO39WgsgMVagzFgqPLxoy2CoLP/Znv76CJAmqS9peUlzp2/QJPHQCU0BmsN1oC1htevXjAajXozAlUl6AQERxZ4/u5Tm6I+DBXFjcEpRARV/d2CqOKc");
			sb.Append("w1q4fukkBmYk3nvU17d6krzEOYc0DVQVEWGaFVXFX+LKAe9Bva9S/TyBiuCcI84KXr790GphtiUPHs/G4AzOOVRkniCKMwZnTzfVNUUl9h6mSf4XAhXEOe7fvvnP+1dt");
			sb.Append("EIhUQ/yfEPlzBmUJwIOth3S73Rm+MaYWCNc2riIinFhdbc+gdI68KAAYDoc8e/KUNEu5t7nZqrq8ssL46xhRpayJK4OyJM9zAKIoIkkS4jgmDMP2RlRRUfr9Pp93d1tD");
			sb.Append("/B5F4bGgExCFEVmWkRfFnEGSJJRlSZamSJPAiFyMptP3YRgd3/u2x/qVywBMJpOWwZfxGPB83NnBLth9AHPY7/wT+9Ie9uKUqZ8AAAAldEVYdGNyZWF0ZS1kYXRlADIw");
			sb.Append("MDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkA");
			sb.Append("MjAxMC0wMS0xMVQwOToyNDozOC0wNzowMNX0vIoAAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBo");
			sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjUwLTA2OjAw2R/2");
			sb.Append("sgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93");
			sb.Append("d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentsave3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentsave3_Reset()
		{
			_Documentsave3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentsave3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentsave3 = null;
		#endregion
		#region Image Documentsaveall
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-all.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentsaveall_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentsaveall, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentsaveall_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall_Cached
		{
			get
			{
				if (_Documentsaveall == null) _Documentsaveall = Documentsaveall;
				return _Documentsaveall;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-all.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentsaveall_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsaveall_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsaveall_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall { get { return _ImageCreateFrom(_Documentsaveall_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-save-all.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsaveall_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsaveall_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall_FromFile { get { return _ImageCreateFrom(_Documentsaveall_string, "document-save-all.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentsaveall
		/// </summary>
		/// <returns></returns>
		private static string _Documentsaveall_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1420);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("BUlEQVQ4y5WTwU5TQRSGv7m9TQO9ews+AD6AJtKYKComBTUxaMLCnYksVAxxwc6FWxG75AHYwcKNW1c+AV1KSWzTCA2tqbfc9nLPzHFxoYUSY/g3M5Mz55//m8kYVeWs");
			sb.Append("Hs7Nh3EcB6/ersBpyYAxHsYzZIwBA+W1j+Ryua7PiKJeFFybmuLe/QfoOQODZ8DzDBnP8GV7i+peNbhgYK2j1+szlsuwsfVtaIBJpwZeLswgIljruGDgnEVESMTy4snt");
			sb.Append("tEMVVXCqOFXC3jEignMWM1+aS5mXV4YuF5iV8toaY/mAWwtLLJaKrL5Z4methj9gnv0f8zbVvSqP7lwnjOI0gbX4l2X+sLqMc5quncW/LPNRGKKqGGNw1qUJRITOUczm");
			sb.Append("1+/De1BQUqPFUnGQ4MfuLk4dVycmEUnwnU0T/IliHs/cGPYrqCqqeo65ULhCs9kkHwT82t/HtycI79+9xpiRN9XTYcicJAkiQsYzSJLgO+uwIkTdkH/pLHOtVkNV2dmp");
			sb.Append("YIzp+iIJcRzzqfyZw8ND8vk84+Pjg8ZnC09RlMnCBCIJ9UbDO6kpgH98nNDv96lUKpTX15kuFrk5PT04vTBRoHlwQHDCrCO/z7ciSTcMs61Wi14U0el0aLfbgw1JHJOI");
			sb.Append("YEzKPCpfVZ+3frc3G41G9u7sLNlslnq9PthQq9dRVSqVlHnU4C+Aw3ZlnVFyrgAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNzowMjozNC0wNzowMLbnjhIA");
			sb.Append("AAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjQ6MjItMDc6MDDMc1vmAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjI0OjIyLTA3OjAwvS7j");
			sb.Append("WgAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xp");
			sb.Append("Y2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDMtMTlUMTA6NTI6NTAtMDY6MDDZH/ayAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2Nh");
			sb.Append("cGUub3Jnm+48GgAAABN0RVh0U291cmNlAE94eWdlbiBJY29uc+wYrugAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL+83qssAAAAA");
			sb.Append("SUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentsaveall_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentsaveall_Reset()
		{
			_Documentsaveall = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentsaveall_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentsaveall = null;
		#endregion
        #region Image DropDown
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku DropDown.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DropDown_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DropDown, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DropDown_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser.zálohy\TraceVisualiser v1.07.10.015\TraceVisualiser\Pics\Pic16\DropDown.png
        /// </remarks>
        public static System.Drawing.Image DropDown_Cached
        {
            get
            {
                if (_DropDown == null) _DropDown = DropDown;
                return _DropDown;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku DropDown.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DropDown_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DropDown_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DropDown_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser.zálohy\TraceVisualiser v1.07.10.015\TraceVisualiser\Pics\Pic16\DropDown.png
        /// </remarks>
        public static System.Drawing.Image DropDown { get { return _ImageCreateFrom(_DropDown_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru DropDown.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DropDown_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DropDown_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser.zálohy\TraceVisualiser v1.07.10.015\TraceVisualiser\Pics\Pic16\DropDown.png
        /// </remarks>
        public static System.Drawing.Image DropDown_FromFile { get { return _ImageCreateFrom(_DropDown_string, "DropDown.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DropDown
        /// </summary>
        /// <returns></returns>
        private static string _DropDown_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(308);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAFZJREFUOE/tjtEJwDAIRB3N0RzNzS69kEBSUCz5K3kgingP5RgAvVQV7o6xrvNjgZlxDov3zKUfRBLePr3nUgF5S2aY");
            sb.Append("lARkStYwKQvIkGx8EoRcwSkiDYw9y+m/K6dDAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DropDown_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DropDown_Reset()
        {
            _DropDown = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DropDown_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DropDown = null;
        #endregion
        #region Image Emblemnotice
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku emblem-notice.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Emblemnotice_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Emblemnotice, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Emblemnotice_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\emblem-notice.png
		/// </remarks>
		public static System.Drawing.Image Emblemnotice_Cached
		{
			get
			{
				if (_Emblemnotice == null) _Emblemnotice = Emblemnotice;
				return _Emblemnotice;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku emblem-notice.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Emblemnotice_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Emblemnotice_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Emblemnotice_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\emblem-notice.png
		/// </remarks>
		public static System.Drawing.Image Emblemnotice { get { return _ImageCreateFrom(_Emblemnotice_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru emblem-notice.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Emblemnotice_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Emblemnotice_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\emblem-notice.png
		/// </remarks>
		public static System.Drawing.Image Emblemnotice_FromFile { get { return _ImageCreateFrom(_Emblemnotice_string, "emblem-notice.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Emblemnotice
		/// </summary>
		/// <returns></returns>
		private static string _Emblemnotice_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1616);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAEnSAABJ0gGoRYr4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
			sb.Append("BUlEQVQ4y02SS2hcZRTHf9/j3rkzk2RmMjGPNmTSVGOzUJIWimAR3Al1UR8bQam4KIiCG/eCOzeiuFHoVqwLi4uKKKjgIhsfkAhWW4kmMS9n0slk5s6duY/vuJhJ9WzO");
			sb.Append("WZzz5/84imE98c5P/LGz6z1Sqy2Xx0av5HK5p7SxC6CMc24nTZLvwm50c69+uDpVneh+tfo98Y1XUACLb36Nsjr/8Ozs05Vy5XWbC5bF6FFBqSG+KOciSZK7Ybt7/aDR");
			sb.Append("+Hhl6dHme88YDJffZ6xS9s7V5p+rVqtvm3zhfKZ1TmulHhw3nK0ajvuiek55ytpp3/Mu+NaLf7nz+1r14oux5os3OD01da5cKr2mc8FDGSACBU/x5ILl2SWf+YpBBBwg");
			sb.Append("np3KF4vXpiYmH99Z+1GZiWufBYu1+ZdGSqUXnDEewECYIm8hTITb9Yx2LJzoUVqXlZPIq0ys6tOTk+P5ILiIMcGJoZ6GhYpGBLZbjtRx/3hgiNLa91aKhWJN5z1/XFt7");
			sb.Append("StR/K1bD2XHN5UWfK0s+06OKo57QTSCTAUOlzQPGetNaQIuIRoboAq2+8O2fCTttR2ChE8Nex7HbdtRDIUwgcaJFxNgoSY7DXnYvyzlSFFEqdGKh2VO0+wNUJ5A5yESI");
			sb.Append("I6ETK0Zc1kqytKEb7WbjuNtbr3eydK/jOOwKUTLQbPSgexr0cBbAZUKWpL/1+9GW3t280wnD4y+JexsMo8pZuDTnMVfSGA2PzRrOlAcqFZCTtC5xeGtrf/PAFC5dRTlX");
			sb.Append("LwaFwPf8ZadtwSjFzJimGQnrBxn7HWGz5Wj1hDwusnF4o33cuO6Tte9bX7v64ezMwvlX/fFTL2f+yLTTWsuQs1KgncOk/aZqNz4/+vv2u2sfPP8r4MxJcq21W+po/+6m");
			sb.Append("9YN/PKWURXzjnDNpP9a9zj052l0P//r5041vPvpk4+Zb20AKuBMGFigAIyg9VqytTI+duTCXL89MoLRJOofN9tb6dmvjh12JwyOgA4RA/P8Hs4AP5IFgOJuhbxmQAD0g");
			sb.Append("AvpDBvIvx8xdrUvbLk8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDg6NTk6MDItMDc6MDCPBRstAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA4");
			sb.Append("OjU5OjAyLTA3OjAw/lijkQAAADN0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvVvf6HAAAABl0RVh0U29mdHdhcmUA");
			sb.Append("d3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAAadEVYdFNvdXJjZQBUYW5nbyBoYXJtLW9uLWljb25zBTECsgAAAEp0RVh0U291cmNlX1VSTABodHRwOi8vZ25vbWUtbG9vay5v");
			sb.Append("cmcvY29udGVudC9zaG93LnBocC9UYW5nbyttaW5lP2NvbnRlbnQ9NzYzMTaO2nU5AAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Emblemnotice_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Emblemnotice_Reset()
		{
			_Emblemnotice = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Emblemnotice_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Emblemnotice = null;
		#endregion
        #region Image EditCopy
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-copy-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditCopy_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditCopy, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditCopy_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\16x16\actions\edit-copy-3.png
        /// </remarks>
        public static System.Drawing.Image EditCopy_Cached
        {
            get
            {
                if (_EditCopy == null) _EditCopy = EditCopy;
                return _EditCopy;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-copy-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditCopy_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditCopy_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditCopy_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\16x16\actions\edit-copy-3.png
        /// </remarks>
        public static System.Drawing.Image EditCopy { get { return _ImageCreateFrom(_EditCopy_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-copy-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditCopy_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditCopy_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\16x16\actions\edit-copy-3.png
        /// </remarks>
        public static System.Drawing.Image EditCopy_FromFile { get { return _ImageCreateFrom(_EditCopy_string, "edit-copy-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditCopy
        /// </summary>
        /// <returns></returns>
        private static string _EditCopy_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(844);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAACXZwQWcAAAAQAAAAEABcxq3DAAAA");
            sb.Append("r0lEQVQ4y62SSwrCMBRFj9ANCeICBAcuyA86MB1EYl2QA8EFSJMsqU6aUOUljcU7CuRxc3J4M9PoM6DIRx12p1q8MY3uxmIa3aWaq3B4PO/iwHq1yaLFgsV8yZTEgta/");
            sb.Append("/kdgXYt1FgBnfXQliRUJnPPst8fsy9fbRQG1SBBeLRGbdVAiNhYMWwNBidgKUP1/phH0K/qxpsF4KUEyPzmQ8k0gFWYLxrYwV5AUO5wBeANHs2kfCbzV9wAAACV0RVh0");
            sb.Append("Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQyMzowNDowNi0wNzowMB4xp9IAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRF");
            sb.Append("WHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjA4OjQxLTA3OjAwCPmpDwAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9H");
            sb.Append("UEwvMi4wL2xqBqgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDYtMDc6MDBBgNHmAAAAF3RFWHRTb3VyY2UAR05PTUUgSWNvbiBUaGVtZcH5JmkA");
            sb.Append("AAAgdEVYdFNvdXJjZV9VUkwAaHR0cDovL2FydC5nbm9tZS5vcmcvMuSReQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditCopy_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditCopy_Reset()
        {
            _EditCopy = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditCopy_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditCopy = null;
        #endregion
        #region Image Error_16
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Error_16.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Error_16_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Error_16, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Error_16_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Error_16.png
		/// </remarks>
		public static System.Drawing.Image Error_16_Cached
		{
			get
			{
				if (_Error_16 == null) _Error_16 = Error_16;
				return _Error_16;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Error_16.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Error_16_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Error_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Error_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Error_16.png
		/// </remarks>
		public static System.Drawing.Image Error_16 { get { return _ImageCreateFrom(_Error_16_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru Error_16.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Error_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Error_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Error_16.png
		/// </remarks>
		public static System.Drawing.Image Error_16_FromFile { get { return _ImageCreateFrom(_Error_16_string, "Error_16.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Error_16
		/// </summary>
		/// <returns></returns>
		private static string _Error_16_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1208);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAADUElEQVR4nF2TXUxbdQDFf/f2lgLlI3AlCGxYO2Fzw7SoMxAmEB6QbS6LMTM+EF2WRR7XxPhBbIZVH0xf");
			sb.Append("HJCo+BEfJGbOxYe9uAeDZiZKDNO6TXQUsIFq0pi29oN72/vx//vg1Ol5Og8nJzk5+Sn8T7FYLNzS0jKl+3xjNdlsAMDS9VS2Wl0qFosL0Wg0cXte+dtEIpG6YDB4rjef");
			sb.Append("P91jWmpTfQP13d2geTHSWxRzWZK1NWLtDv39dDp9Jh6Pm/8URCKRun179nw2kFwf6e3rp66tDWwbhABFAU0Dnw9ze4u1xArLfQeubG5vT8TjcVMDCAaDswM310b2HRyi");
			sb.Append("FLoPcztN61YKXBcUBen1kgv1g97PgaZmWP5q2Oq5ZxZ4xjMzMxMOVypvh9u6FOPhIVr2340W2EVxM03dRhJZLpM7+BDNhx6gtrONQrlKp+plp5jv3zs6eknTdX2qZ/0X");
			sb.Append("tfbObixFAqBpHvwnHiVb+AN2ddE8OoAUEtdxcX9I4Fv6nF5/vfrTg/dPaa01NWPNqgePUabhwkVKjx2nsa8XTfPQcHoS13Uxdgwc18Vc/ISOV86ClPgdB31ocEz15XIB");
			sb.Append("f0cHWBZeo4z/zbcofXcD06xgGAamYVKpVjE+vEDHqy+j3nqt3nHwZbMBDUDxeMCxoVJBu5bA/GYZ7a4uhBAIIXBdF/X6DVThgmVBpYJ03b/mVltbU6U3zvX6GhuRySS/");
			sb.Append("vTCNeuI4tm0jhEBKiZASa/pZfjV26Dq/iABKikJV11Nq3raXCs1NyJs/k37+ReTkEzi2g+M4uBcvIVYSOI6LkJLS2ZdIPf4kBSAbDpOzrCU1k8ksrI+Pix2tBjF8CMcR");
			sb.Append("OK6Le/5Tdk8/R+fJp5FXv8dxBRJBbniYDLB99KjI5/MLAMzPzy8kjh2T5Xv3y/UvvpTrr70uXdUjBcgKyN8bGuW1xY/kt+9+IK/W1suvjxyRc3Nz7wBoAKurqxHv+Phe");
			sb.Append("xOWR4MQEfquKLSUmYABGuYR78ilsCdYj41w/fPjK5sbGGQAPwMrKirM7EPjYHBxsM0KhflEqKaVMhiJQAAqKgh0KUTh1SvwYCr2X3NiYnJ2d/Rem2xWNRsPt7e1TLV7v");
			sb.Append("mO8WzlVdT+UsaymbzS7EYrH/4Pwn1OaZvEkYDwwAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Error_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Error_16_Reset()
		{
			_Error_16 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Error_16_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Error_16 = null;
		#endregion
        #region Image GnomePlanner
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku gnome-planner.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GnomePlanner_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GnomePlanner, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GnomePlanner_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\gnome-planner.png
        /// </remarks>
        public static System.Drawing.Image GnomePlanner_Cached
        {
            get
            {
                if (_GnomePlanner == null) _GnomePlanner = GnomePlanner;
                return _GnomePlanner;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku gnome-planner.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GnomePlanner_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GnomePlanner_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GnomePlanner_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\gnome-planner.png
        /// </remarks>
        public static System.Drawing.Image GnomePlanner { get { return _ImageCreateFrom(_GnomePlanner_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru gnome-planner.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GnomePlanner_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GnomePlanner_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\gnome-planner.png
        /// </remarks>
        public static System.Drawing.Image GnomePlanner_FromFile { get { return _ImageCreateFrom(_GnomePlanner_string, "gnome-planner.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GnomePlanner
        /// </summary>
        /// <returns></returns>
        private static string _GnomePlanner_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1020);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("ZElEQVQ4y62SvW4UQRCEv9rZPQkdwiAShEicOLUcITlCIiPBkXkC+xEICciI/AAOLOd+giOx5MgxzgguIkPc6bCEYXemCHbOu3f+uQBG6unpaU1NdXXLNv+ySoCNd0cm");
            sb.Append("A/V3FsBv3n092VcJ4BTZ291GGEkIkAAZIQoBIt+38cHxaccAJ6pgvown2GA7GxhfxynnXm89xyl2AE6RKojff5reY3dgdHGyGZQCpx6AI4NSvNp8RqGWfutFoXkJ6uW0");
            sb.Append("yAAnPh2OIFNeEM49ARdEbL1sI6kChj17CDwCHud4CsyAn8BlthnwS/9lDpbXt5HszHZewfw8/2/9jXUnQB3hxcv3bfMJIGEXQAEKjM8+3M+gbsAW8eocSNgxty0Rhm+p");
            sb.Append("mxUlNA0kF6Q4AyfsBETsRKCiWQVQR4CKMNxpSyCAAlBilTm/gsHF54+daD0Bl8fi1jZKegCsZXsCPM3n78AP2rmYANO/tUjJtWkt9nQAAAAldEVYdGRhdGU6Y3JlYXRl");
            sb.Append("ADIwMTAtMDEtMTFUMDk6MTI6MzYtMDc6MDBgamktAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjEyOjM2LTA3OjAwETfRkQAAADR0RVh0TGljZW5zZQBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9HUEwvMi4wL2xqBqgAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRTb3Vy");
            sb.Append("Y2UAR05PTUUtQ29sb3JzqplE4gAAADF0RVh0U291cmNlX1VSTABodHRwOi8vY29kZS5nb29nbGUuY29tL3AvZ25vbWUtY29sb3JzL1AdtesAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GnomePlanner_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GnomePlanner_Reset()
        {
            _GnomePlanner = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GnomePlanner_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GnomePlanner = null;
        #endregion
        #region Image GoDown3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-down-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoDown3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoDown3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoDown3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-down-3.png
        /// </remarks>
        public static System.Drawing.Image GoDown3_Cached
        {
            get
            {
                if (_GoDown3 == null) _GoDown3 = GoDown3;
                return _GoDown3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-down-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoDown3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoDown3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoDown3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-down-3.png
        /// </remarks>
        public static System.Drawing.Image GoDown3 { get { return _ImageCreateFrom(_GoDown3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-down-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoDown3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoDown3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-down-3.png
        /// </remarks>
        public static System.Drawing.Image GoDown3_FromFile { get { return _ImageCreateFrom(_GoDown3_string, "go-down-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoDown3
        /// </summary>
        /// <returns></returns>
        private static string _GoDown3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1268);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("yUlEQVQ4y6VSu24TQRQ9M15bOHIQtuWgkCJMhWiQeDRBApQmBYto4AsQf0DBlulYPoIvgDJbQhlEgbAUCQWacTZxEpHHruP1jr2PuRRrQ2LtmoKRRle6c+ecc++5jIjw");
            sb.Append("P8eYTgjTjgCUC+rr0rH8mQAA2POnD8FLHBwanDQA4P3G5ihO9L8VAECqCd/dY4SDEYJwiAe3llDUKc8HGDOxLOQxzwZIMzpCFpNUo2jYuQCJnhRnEuK0WIEhTPsFgHeT");
            sb.Append("RNng0Fpf6DlOUlQqZUMNI0+Y9iT9DcAqIyKIJ2/X52tzr+7evlnjRgmBitAPYygVIRgoNOYvoVWvgjOG3e6vpOMe7oHonnSsEw4AcuP1ehCEH9pbP8NRFEMNkzFJJsML");
            sb.Append("hhioGLv7R2nHPTwC0X3pWCcXZkBEL3t+f/PHtlS1qgHO/rqwUJ+D3+vrzs6BN/588Gdpzk9XmHaVMfaldbV5Y3l5qXLsK1Q4YaQUdXa6PRCtSMfaPj9ENm2PMO0mGGsv");
            sb.Append("XltYbLWaJd87g+t2z0D0SDpWe9oFluevMG0Bxr42GvUrp6feAERr0rE+59nIihZEmPYdAJ8APJOO9bFwEYio8F5//ObyrHciwm8keglzpjMHzgAAACV0RVh0Y3JlYXRl");
            sb.Append("LWRhdGUAMjAwOS0xMS0xNVQyMzowNDowNS0wNzowMC/ZvU8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRl");
            sb.Append("Om1vZGlmeQAyMDEwLTAxLTExVDA5OjA4OjM3LTA3OjAwYeyVLAAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9HUEwvMi4w");
            sb.Append("L2xqBqgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDUtMDc6MDBwaMt7AAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABd0");
            sb.Append("RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoDown3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoDown3_Reset()
        {
            _GoDown3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoDown3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoDown3 = null;
        #endregion
        #region Image GoUp3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-up-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoUp3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoUp3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoUp3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-up-3.png
        /// </remarks>
        public static System.Drawing.Image GoUp3_Cached
        {
            get
            {
                if (_GoUp3 == null) _GoUp3 = GoUp3;
                return _GoUp3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-up-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoUp3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoUp3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoUp3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-up-3.png
        /// </remarks>
        public static System.Drawing.Image GoUp3 { get { return _ImageCreateFrom(_GoUp3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-up-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoUp3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoUp3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-up-3.png
        /// </remarks>
        public static System.Drawing.Image GoUp3_FromFile { get { return _ImageCreateFrom(_GoUp3_string, "go-up-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoUp3
        /// </summary>
        /// <returns></returns>
        private static string _GoUp3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1236);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("sElEQVQ4y42STWtTQRSGnzP3pk1sktpGTGzTkFGvjaJRi4KYnbjqXbv2b3Tnsvc/dONOXHbRjSCK6EZBiBvFTagIClKLaJvPO8dFohjJbfPCcDhzZp55OXNQVZJWdX0z");
            sb.Append("f1RdVTEkyIbRGvDJhtEdjpBJuGwReXp5tTJvPLNtw+jW1AAbRgVEXly/cjYfnCvTuFHLipEnNozqxwJsGGVE5Nnq+eViqXTavGvtIf4MN68FWUSe2zAKEgE2jDwR2V5e");
            sb.Append("OhVUq+XU52+/iJ3j/e4e6UxG6pfsPCKvbBhVJjsQ2Sos5m9frNn0l++HDJyCgip82N0nl8+aWrCyOIIUxwA2jB7ksifuXa1fmEMMmRnvDxWAhdwsnjEslQqerZwpIvLS");
            sb.Append("htECgFTXN+8DDwEngqZ8TxqNNfN1v81hu8vBQYegfJJm82O/3e0aVQA84DVw1wceAY9haLfXj386p2PNjWOl0+s5VVaAH/+Uen5rZ6P3308QOx1lw9iPHTp8utva2egc");
            sb.Append("O0iD2I06IGP51JP418Eo9AfJAD8JMJf28cWR8pTYOVSnB+jbN81JZ2cnbYomoafUb7KJv5pbiBHKAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjA1");
            sb.Append("LTA3OjAwL9m9TwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNy0wNzowMJGkTagAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MDg6");
            sb.Append("MzgtMDc6MDCXpOXFAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAAACV0RVh0bW9kaWZ5LWRhdGUA");
            sb.Append("MjAwOS0xMS0xNVQyMzowNDowNS0wNzowMHBoy3sAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAF3RFWHRTb3VyY2UAR05PTUUgSWNvbiBUaGVt");
            sb.Append("ZcH5JmkAAAAgdEVYdFNvdXJjZV9VUkwAaHR0cDovL2FydC5nbm9tZS5vcmcvMuSReQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoUp3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoUp3_Reset()
        {
            _GoUp3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoUp3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoUp3 = null;
        #endregion
        #region Image GoNext3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-next-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoNext3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoNext3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoNext3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-3.png
        /// </remarks>
        public static System.Drawing.Image GoNext3_Cached
        {
            get
            {
                if (_GoNext3 == null) _GoNext3 = GoNext3;
                return _GoNext3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-next-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoNext3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoNext3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoNext3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-3.png
        /// </remarks>
        public static System.Drawing.Image GoNext3 { get { return _ImageCreateFrom(_GoNext3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-next-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoNext3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoNext3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-3.png
        /// </remarks>
        public static System.Drawing.Image GoNext3_FromFile { get { return _ImageCreateFrom(_GoNext3_string, "go-next-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoNext3
        /// </summary>
        /// <returns></returns>
        private static string _GoNext3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1256);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("wElEQVQ4y51TXWsTQRQ9s0k01NA+JI0EFbuCPlUQH4QoKigoZh99911/wfwD94/4B4QBnxUfhFYQav3aOGqSak1rErLb/Ugyx5d2W9NuCh6YmYd77pk7Z+4FSWStpcbT");
            sb.Append("J7PiJCFIIgu24/pCiGckH2slzVEcC7ORq5TnHwkhntuOe/J/BHD92nJx6dzpu0KI17bjLkzHBUnYjjsEUJoOFvIWHtyrY2KIptcafWq22yRvaiU70wJh4369aFn7BQkB");
            sb.Append("kMDAj9H3Y9TKc9jY2JysffjeA3lbK7kOAPm9hLEhOpsDmAxPO1sBqtXF3JVcvvzuffON7bgNreSrVCCJE+yEMYwBgD0Vsb8LQIcRzlcXxMULZ0ufvdYL23HtVCCKEgRB");
            sb.Append("DDPjW89USuj1B/B0ZwfAQ63k71RgNDawa/P/JJBA34/xZxihVj6FJIrw8cs3n4aOVvLlQQ/Gq2/XJ9M35nOWWL58ySoU5hAGAb2vbR/kHa3kSsrZPSvpgw9gPDG9ZGSK");
            sb.Append("/nBofrR+DUDe0kquHeqDLNiOGy5WKye63e0tkDe0kt6hKjEb7Ha3f4KsayVbRxGOa+UVkFezknednjnOpePG+S/Uey3FSrKfigAAACV0RVh0Y3JlYXRlLWRhdGUAMjAw");
            sb.Append("OS0xMS0xNVQyMzowNDowNi0wNzowMB4xp9IAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAy");
            sb.Append("MDEwLTAxLTExVDA5OjA4OjQxLTA3OjAwCPmpDwAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9HUEwvMi4wL2xqBqgAAAAl");
            sb.Append("dEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDYtMDc6MDBBgNHmAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABd0RVh0U291cmNl");
            sb.Append("AEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoNext3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoNext3_Reset()
        {
            _GoNext3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoNext3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoNext3 = null;
        #endregion
        #region Image GoPrevious3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-previous-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoPrevious3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoPrevious3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoPrevious3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-3.png
        /// </remarks>
        public static System.Drawing.Image GoPrevious3_Cached
        {
            get
            {
                if (_GoPrevious3 == null) _GoPrevious3 = GoPrevious3;
                return _GoPrevious3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-previous-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoPrevious3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoPrevious3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoPrevious3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-3.png
        /// </remarks>
        public static System.Drawing.Image GoPrevious3 { get { return _ImageCreateFrom(_GoPrevious3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-previous-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoPrevious3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoPrevious3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-3.png
        /// </remarks>
        public static System.Drawing.Image GoPrevious3_FromFile { get { return _ImageCreateFrom(_GoPrevious3_string, "go-previous-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoPrevious3
        /// </summary>
        /// <returns></returns>
        private static string _GoPrevious3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1276);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("z0lEQVQ4y51T3WoTURD+5uyWbKrb7CatG5PGJikFKUUvBC8UfIAGfALR19g3aHwBH8BHEPZCKkoVFdFLRUFwhUpj25gmdnfZH/aMN9uYttkgHvg4FzPf983MmQNmxiw0");
            sb.Append("N7fuNTe39Ly4wIzT6jy0ATwGoOTlqNOJXSKiR6Zx4f7ot59KybkmYgq5QERPLi2WHty5fX1eVUQ6q0pi5klyiYieLdcqG9c21jRFVfBi50N67IV5LZhjgVanWyeil+3m");
            sb.Append("5cbq6pW5g6MAmqaislCEoHO+eLr9NoqTtKpm5HUQ7Vxda5i1uqXs/fKRSkbkxRh58TnbFUvHibHa6nQLALYbtcWKZS3R994IaTa0v93x2JnBiGMNMgsK17EjAHd39/rH");
            sb.Append("P/f7XCqq8IMQnh/CD04QZQgRBBGiMB6LT85gHUSv2s26oZd00ev70OfnUF7QICgbQnYLAt69/xhJydWzr9AG0ZvGslUxTENVFYHPn74mYZxMWzgFgHkq4Dr2NzDf2P2x");
            sb.Append("3zs86CdSMqIkkQDqAC6eQdF17OGpCiYqWSKi1+WysTIYHDEzqq5jD/9pE7NKDpn55mAw/MKMwqxNzP1MrmMPmfkWgOf/JZCJ+AA6ALy8nD8Z1vctgFpWxwAAACV0RVh0");
            sb.Append("Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQyMzowNDowNi0wNzowMB4xp9IAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRF");
            sb.Append("WHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjA4OjQwLTA3OjAwro6iuwAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9H");
            sb.Append("UEwvMi4wL2xqBqgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDYtMDc6MDBBgNHmAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48");
            sb.Append("GgAAABd0RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoPrevious3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoPrevious3_Reset()
        {
            _GoPrevious3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoPrevious3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoPrevious3 = null;
        #endregion
        #region Image GoNextView
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-next-view.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoNextView_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoNextView, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoNextView_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-view.png
        /// </remarks>
        public static System.Drawing.Image GoNextView_Cached
        {
            get
            {
                if (_GoNextView == null) _GoNextView = GoNextView;
                return _GoNextView;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-next-view.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoNextView_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoNextView_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoNextView_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-view.png
        /// </remarks>
        public static System.Drawing.Image GoNextView { get { return _ImageCreateFrom(_GoNextView_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-next-view.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoNextView_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoNextView_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-next-view.png
        /// </remarks>
        public static System.Drawing.Image GoNextView_FromFile { get { return _ImageCreateFrom(_GoNextView_string, "go-next-view.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoNextView
        /// </summary>
        /// <returns></returns>
        private static string _GoNextView_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1324);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("vklEQVQ4y6WTzUsbURTFz0wmqZoJwS5EKBZBI3QhEqqgIKUI7tsixrgQXFh3Ylf+Fy5c6cpCxU900UWhm4KCUorSLGpLG6SCMUS0OuPM5H3Mm/e6jR9pYj27s7g/Dufe");
            sb.Append("qymlcB8ZpSYxOL8D/cGJrmtjPxfTZ9UA9FITCNbT3R5/oSmRSQwv9dwZIH2K4VddmBjpePSwLthKpBff3A0gKP6cWYibtXg9lDSeNIWn21ILGy2Da/EqEzDYtgfL9kAp");
            sb.Append("R39vC54l4y/DRjGTSC8nq+iAwvUYPI/DdTkch6CpMYb+p/XNpkE+tw0tjFfsgDAFwiWKNIDj+sgXbBzlTqGTXIRf5mdbU/Nvy65RCop8gUAqgHMBQik814FjE3BfQgqi");
            sb.Append("BLFPywN8ikikBtCAUEgAGiCED+v8AhcOczSERw/fT66XBQSCwoxFAaXAGIeUEtnjI/zOZjPKCA2cbM8cXO/gRoKYGUUQSFBCsLP5EYXj3Ny5YBPq2yq/bQvXOmCImVH8");
            sb.Append("+rGPjdV3TtF1x6zv6yv/OiSt9Jlqm/tUZ3cvvu592TOgp6zshwNU0BVA3ePnGQnxiTXQKbW761cavgH4H/0FRdrmc6/e+GMAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDkt");
            sb.Append("MTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI0OjM0LTA3OjAwYwluQgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAx");
            sb.Append("MC0wMS0xMVQwOToyNDozNC0wNzowMBJU1v4AAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRw");
            sb.Append("Oi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTA2LTAzVDA5OjU4OjEzLTA2OjAwLJplVwAA");
            sb.Append("ABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cu");
            sb.Append("b3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoNextView_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoNextView_Reset()
        {
            _GoNextView = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoNextView_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoNextView = null;
        #endregion
        #region Image GoPreviousView
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-previous-view.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoPreviousView_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoPreviousView, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoPreviousView_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-view.png
        /// </remarks>
        public static System.Drawing.Image GoPreviousView_Cached
        {
            get
            {
                if (_GoPreviousView == null) _GoPreviousView = GoPreviousView;
                return _GoPreviousView;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku go-previous-view.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoPreviousView_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoPreviousView_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoPreviousView_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-view.png
        /// </remarks>
        public static System.Drawing.Image GoPreviousView { get { return _ImageCreateFrom(_GoPreviousView_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru go-previous-view.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoPreviousView_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoPreviousView_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\go-previous-view.png
        /// </remarks>
        public static System.Drawing.Image GoPreviousView_FromFile { get { return _ImageCreateFrom(_GoPreviousView_string, "go-previous-view.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoPreviousView
        /// </summary>
        /// <returns></returns>
        private static string _GoPreviousView_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1328);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("wElEQVQ4y6WTTUhUURiG3/Nz77k20Ewq6jALA2cmyECGJsFWraKlBYlOLWpTm1q0ad++lVsFCURjpCDaSxRBK9FIXGhCDeh4x7+54/2be+85rYRkarziu/zO9z285/3O");
            sb.Append("IUopnEc8buOV0ny3lGoK0u9dLz++eVyncYZzpfkRosLl4WsXR6PQH/n77FRAbmLuRcoIPz97MJh5eO8GZODFu8LA2EKSEX9mII27o7cHYRg6dqomZBgDkJt4W+DMe1/M");
            sb.Append("6ZeHrmbg2C48rwkQAhn47QH58dmnF5g3eT0v9K5LHbAsF0IYYBpACUXUzkF2/M1MijceZdMUTTeExTkSSoOigKAMjPH2GUjXqtWjQ7VUNUkylUJfGujpM8AEB+McCrwl");
            sb.Append("gxNb2Pzw/KXnhPfrvmiYuzZ2D1zs1yPUjyIEkQ6mJVoctKyxsvjqHWSz4LnOinV4AE3TIXQdiUQHero7WzL45zvY+Tr507T3h6uVjamlb4twbBtBEKJx5Jzu4FjqR7m5");
            sb.Append("tzL3pLa1WfpYnm6srX6HWduDDNwTfSTOZ0pm72QjROVMf77we2MV7q9P5EwAACDFoia2xWtK6S2n8mXozID/6Q/wfcKoI875KQAAACV0RVh0Y3JlYXRlLWRhdGUAMjAw");
            sb.Append("OS0xMS0xNVQxNzowMjozNC0wNzowMLbnjhIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjQ6NDAtMDc6MDCdg0NIAAAAJXRFWHRkYXRlOm1vZGlmeQAy");
            sb.Append("MDEwLTAxLTExVDA5OjI0OjQwLTA3OjAw7N779AAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0");
            sb.Append("dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDYtMDNUMDk6NTg6MTMtMDY6MDAsmmVX");
            sb.Append("AAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABN0RVh0U291cmNlAE94eWdlbiBJY29uc+wYrugAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3");
            sb.Append("dy5veHlnZW4taWNvbnMub3JnL+83qssAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoPreviousView_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoPreviousView_Reset()
        {
            _GoPreviousView = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoPreviousView_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoPreviousView = null;
        #endregion
		#region Image HelpAbout2
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku help-about-2.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu HelpAbout2_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property HelpAbout2, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property HelpAbout2_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\help-about-2.png
		/// </remarks>
		public static System.Drawing.Image HelpAbout2_Cached
		{
			get
			{
				if (_HelpAbout2 == null) _HelpAbout2 = HelpAbout2;
				return _HelpAbout2;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku help-about-2.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image HelpAbout2_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HelpAbout2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property HelpAbout2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\help-about-2.png
		/// </remarks>
		public static System.Drawing.Image HelpAbout2 { get { return _ImageCreateFrom(_HelpAbout2_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru help-about-2.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HelpAbout2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property HelpAbout2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\help-about-2.png
		/// </remarks>
		public static System.Drawing.Image HelpAbout2_FromFile { get { return _ImageCreateFrom(_HelpAbout2_string, "help-about-2.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru HelpAbout2
		/// </summary>
		/// <returns></returns>
		private static string _HelpAbout2_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1532);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
			sb.Append("WklEQVQ4y6WTMUxTURSGv3Pve/dRSqFQlMKkCQqDiYPGQSbj5iAOYsCYOLAYEl0NiXFxMNHFMBgWEp0g4CA6MOFmoosaFyMhDoqkwKsYW9q+175eh9a2Cps3+XNzb06+");
			sb.Append("e85/zxFrLf+znH8v5MKKR2dxUpSaGOiJ91WhK/Or/MnCAuIt2afns3/Ft2Yg4y9He7vM7MVT6fTQQAd+LkSAns421jJFlt/72Ww+GrVPzr3eB5BrKyOD6fZXl8/0G0cr");
			sb.Append("fuQCHkwMIwLTi2t0dsSoVC3P3mXDdT+8YmfPLgMoALm+mkolY8sjw73GL0Rk8hVSCZe4p2k3mv5kG5lchF+oMnKs2/R2xmbl1rrX9MCRsaN9iVS2YEGqIMKXnRKLb7fQ");
			sb.Append("GlbXcrTFYiACIhw5HE/7G/lJ4LED4BpvAu2wVaiVE0VVCkHEnRdfQYRERzvaAgKIBeXgOt7VBqAszvGPW2WSMQfP1QSlgK2Hpxvm9t3+gBd3QSCI4GcpoqzcnoYHaHc3");
			sb.Append("tA7bRWEjD37ZoG68aQB2SvB9Dzb2hO2SIhQXHLe7xQOTrdWnsCJYEbDVBsCKxirT8ABRIHxuycDMow1oty4DqqXHtAOOW5ep795CExCqORx3sxEgCqKoCYii2suOqcGU");
			sb.Append("8jHeUgNgZwYDtJlCmwDtQiXEzpxslvDoBITFP8cA0ZfsdCK7v5XvbY9g1XNVjXrTTpGBhOJQXMjkLd9KMfxQbQJT9m5q+cBZAJD7uRSVYAwr40oYUsJupWqziMyT3J2z");
			sb.Append("NweDA4dJRAzQ1iKv/ksKiIAyEAKluorW2spvz5rjlbmEzG8AAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRl");
			sb.Append("OmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDozNS0wNzowMLQj3UoAAABndEVYdExp");
			sb.Append("Y2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BM");
			sb.Append("LzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjUxLTA2OjAwf2j9BgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoA");
			sb.Append("AAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property HelpAbout2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void HelpAbout2_Reset()
		{
			_HelpAbout2 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití HelpAbout2_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _HelpAbout2 = null;
		#endregion
		#region Image ChartLineStacked
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku office-chart-line-stacked.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ChartLineStacked_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ChartLineStacked, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ChartLineStacked_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked_Cached
        {
            get
            {
                if (_ChartLineStacked == null) _ChartLineStacked = ChartLineStacked;
                return _ChartLineStacked;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku office-chart-line-stacked.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ChartLineStacked_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartLineStacked_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartLineStacked_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked { get { return _ImageCreateFrom(_ChartLineStacked_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru office-chart-line-stacked.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartLineStacked_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartLineStacked_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked_FromFile { get { return _ImageCreateFrom(_ChartLineStacked_string, "office-chart-line-stacked.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ChartLineStacked
        /// </summary>
        /// <returns></returns>
        private static string _ChartLineStacked_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1532);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAbrwAAG68BXhqRHAAAAAl2cEFnAAAAEAAAABAAXMatwwAAAjZJREFUOMuNk01IVFEUx//n3vfeOJa0");
            sb.Append("iWjhLkIQZJAUN88+nRjKGikwCwlDQsNFEChzyzdKLpwIglYFMVuDUQQx+8LIYMJFgUFtWkaboE3Ic2ac9+49LdRZ2Kid1YHz/517vi4AQCl1Ef9ps8fraPaUvDB7GjEA");
            sb.Append("EEqpBiFE0vO8ht3Al60xmm87mpQm+pnYGXcEBAAIAMlNTXIn+FVTh9BBdIq1M046ct8x+1o6F7FSEXiel93t9YXG84/mm04svWhujWyPWQAghNgRfn2k747WflwSt59b");
            sb.Append("+bBeNQEzV4frh6+Y0L8tybiJ7zN/qmmsVCqVZWZ3e+DNwQcJE/qPiYN44seTnztVaGUymf50Ol2ZwbvaaRnKVQ/Gv0k6uJz4NfF1bIHtugie769BrK4G07UOpm0LK52N");
            sb.Append("tLEKAwMAWBRLh4PQfssm0o6w5lji9+jHwanAXiuUc34xkDo017QBmJED0FdpwbB2F7HcwsbMSVP7jAJMdKz16ktPS3axFOYkE2zb6h46KQMAnwDc3apYZDKZfiLKE0Ro");
            sb.Append("QV6Nh2fHO8pduv1h0S6WTK5YZpS07J7skkHVGQAAMXAGbV8A4NBwof6Aw72Fkr5hgb5Ztt2Tu25XhSstEMN1bhWaJfTk+rpuKQuaKRvZV9Ry+f2Qgz1t9J7KWgN+zBlY");
            sb.Append("7XEG/ehees/zRrb+DgHAWNrLGqMBNgAJl0jkQQLM7BJRfvPYXCLKMzOM2diaMWbun+ypVCq7l6+UGlFKNQDAX3HM8XhWw3aEAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5");
            sb.Append("LTExLTE1VDE3OjAyOjM0LTA3OjAwtueOEgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwOToyNDoyMS0wNzowMP2bQXsAAAAldEVYdGRhdGU6bW9kaWZ5ADIw");
            sb.Append("MTAtMDEtMTFUMDk6MjQ6MjEtMDc6MDCMxvnHAAAAZ3RFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0");
            sb.Append("cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvW488YwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0wNi0wM1QwOTo1ODoxMy0wNjowMCyaZVcA");
            sb.Append("AAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ChartLineStacked_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ChartLineStacked_Reset()
        {
            _ChartLineStacked = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ChartLineStacked_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ChartLineStacked = null;
        #endregion
        #region Image ChartOrganisationDelete
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku chart-organisation-delete.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ChartOrganisationDelete_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ChartOrganisationDelete, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ChartOrganisationDelete_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\chart-organisation-delete.png
        /// </remarks>
        public static System.Drawing.Image ChartOrganisationDelete_Cached
        {
            get
            {
                if (_ChartOrganisationDelete == null) _ChartOrganisationDelete = ChartOrganisationDelete;
                return _ChartOrganisationDelete;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku chart-organisation-delete.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ChartOrganisationDelete_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartOrganisationDelete_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartOrganisationDelete_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\chart-organisation-delete.png
        /// </remarks>
        public static System.Drawing.Image ChartOrganisationDelete { get { return _ImageCreateFrom(_ChartOrganisationDelete_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru chart-organisation-delete.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartOrganisationDelete_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartOrganisationDelete_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiser\TraceVisualiser\Pics\Pic16\chart-organisation-delete.png
        /// </remarks>
        public static System.Drawing.Image ChartOrganisationDelete_FromFile { get { return _ImageCreateFrom(_ChartOrganisationDelete_string, "chart-organisation-delete.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ChartOrganisationDelete
        /// </summary>
        /// <returns></returns>
        private static string _ChartOrganisationDelete_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1376);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAcRJREFUOMulkT9oU1EUxr+b94jR4FQENaahgjoICs6l0FoNqOAUbJcgOIhO4lQQpJO4ubVDBBG6FiFSA3GIRV2lSHEQLA61tAgl78/9++65");
            sb.Append("1+2haGq033i+w+98fId577EfhYOMhVXuhbFIlUEkFJ7cqLI/7RUGAYS2mDgOXKyE6Kfi3xPEUkPKEEoRoug/AP1U4dkHgSgRiGM5EMD2W2JhL7PT6fh2u73nhTxBr9fz");
            sb.Append("zjkQEbIsg1IKQghIKcE5R5qm4Jzns1arxX7pwBiDer3OMISazab/LcHf9H62Nmd5/47lokqB3wSwcLlrH7N7q7c8OQI5B+cIi9NLDABuvmp4bTWUNrjwaQfXk5I5PdUo");
            sb.Append("Hhg7C/mxi/W3r/E020bBksV05RounbiKjGx+UWUKE5VJjI+O48zaZ5yaahRLX96APZ/FoY0XOFkbweRWjNASgZyF8wRLlAOk0ohNhNQkOB8blI6OAVfu5344fwxHBCG0");
            sb.Append("ZPFyYxnkHMj9BNAKK+sdaG1wrhxArK2g3L4LLbchACRxgN2DwXAlvpupzBcPlx9UR2wYFjaRfLf4uhNQpvzD4b8wMzrHd7duB8RqFPhvHlisd+2jH3gJAzmkCTU9AAAA");
            sb.Append("JXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwNjo1MzowMC0wNzowMPVeln0A");
            sb.Append("AAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTM6MDAtMDc6MDCEAy7BAAAAYnRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vu");
            sb.Append("c2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uGPGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6");
            sb.Append("NTA6NTAtMDc6MDBC4I5JAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0");
            sb.Append("RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ChartOrganisationDelete_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ChartOrganisationDelete_Reset()
        {
            _ChartOrganisationDelete = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ChartOrganisationDelete_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ChartOrganisationDelete = null;
        #endregion
        #region Image Info_16
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Info_16.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Info_16_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Info_16, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Info_16_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Info_16.png
		/// </remarks>
		public static System.Drawing.Image Info_16_Cached
		{
			get
			{
				if (_Info_16 == null) _Info_16 = Info_16;
				return _Info_16;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Info_16.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Info_16_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Info_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Info_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Info_16.png
		/// </remarks>
		public static System.Drawing.Image Info_16 { get { return _ImageCreateFrom(_Info_16_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru Info_16.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Info_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Info_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Info_16.png
		/// </remarks>
		public static System.Drawing.Image Info_16_FromFile { get { return _ImageCreateFrom(_Info_16_string, "Info_16.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Info_16
		/// </summary>
		/// <returns></returns>
		private static string _Info_16_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1280);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsSAAALEgHS3X78AAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
			sb.Append("FUlEQVQ4y6WTX0gbdwDHv/e7P7+75LwLbVprTEy3jpXOqEglBbs1Q50MoQ8DYY4x9thp6csQ2XOlhW6DSim4PW9sCsJehx0ypmwmC5q2ajXVtRgTNbnWJjGnl9/lbg+l");
			sb.Append("lI699fv05cuXL9+XD/Ca4v4bjI5eRTKZpLFYLHjM7w9wHFAoFHJ37vy21dFx1ro6eu2VvvDC9Pb2Ynp6mgsEAtGhoaFBKnti4ES/43IINL1ltLa1zz76Z30cQDwajTqJ");
			sb.Append("ROLlg66uLszMzHATExP99fUnvqkRNVyyRJQqLiqWA9uuoU6uIXTUyTzZeTQy8Mmnk+3t7e7i4uLzgXQ6jbm52XMn3zg1WYUefmqK2Ddt+DQFFgM2sibMKqBShuibdmZ9");
			sb.Append("JTHwflf3n5FIC0hfXx86z3dKjY2NXzDXE86XeOyVqwBH0H2uCR+eD4PjBZhVgmzRi9SmGGoIhgdbIi00FotB6O/vR09Pd1CUlAvbZYK9MkO2YCJbOESgXgfhBSRWK3AJ");
			sb.Append("hdcrwHZUnFCkd4e/vBKSFG1diEQieJhebai5gn93z8Zf9w2kHhYhyzIG2D4IRPBUg1WTYDkUJUbwzBT8mlYXON7QtC4AACEcLObi92QOybUSRKrgmKaB8gySwEHXfTiw");
			sb.Append("JYiiCJ64sGs1MFYFYwxCKpWCdVDeVvRGI5uvaCJV4PGqUFUdvCBBFCUoHhWwRfA8D8ktgdjPDMN4kts/cECmpqYwPDyy5ZWcP6Lv+ECpAo9HheJRISsyqCyDUgpRkkB4");
			sb.Append("AUf4DGDl53748afM/Pw8+I2NDdxfWqqtLN3baT0T/GC3yPkqdh28dTosV8NmUYVRkeGCQHU2EeIXMtubD766dOny45tjY+ABIB5PYPy773MfXezJdpzxRzkOPpNJKJge");
			sb.Append("PK0IELGPo1hDiF/IFHdXR65dv/Hr6toa8vn8Sxba2lpx9+497vatm9GG4MnBskVjpUPRz2wbxN4z3MP87E728fjX347Fm5ubneXl5f+H6fPPPsbKgzS98F5n0KfrAcaq");
			sb.Append("KBSMXPzvha3Tb5+yfp785XUBflX/AhQmQducJ0TNAAAAKHpUWHRTb2Z0d2FyZQAAeNrzTUwuys9NTclMVHDLLEotzy/KLlawAABgFQgngoM2iwAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Info_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Info_16_Reset()
		{
			_Info_16 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Info_16_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Info_16 = null;
		#endregion
        #region Image InsertComments
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku insert-comments.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu InsertComments_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property InsertComments, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property InsertComments_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiserOld\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image InsertComments_Cached
        {
            get
            {
                if (_InsertComments == null) _InsertComments = InsertComments;
                return _InsertComments;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku insert-comments.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image InsertComments_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití InsertComments_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property InsertComments_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiserOld\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image InsertComments { get { return _ImageCreateFrom(_InsertComments_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru insert-comments.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití InsertComments_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property InsertComments_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\TraceVisualiserOld\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image InsertComments_FromFile { get { return _ImageCreateFrom(_InsertComments_string, "insert-comments.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru InsertComments
        /// </summary>
        /// <returns></returns>
        private static string _InsertComments_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1436);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAfFJREFUOMuNkk1rE1EUhp+ZJkOtk1pqqStBLVEXdSG0bly5GlBcCok/oKAgbseNukvwHyilkWwCZilCklJdJEgFCRRqSkiJ2NLiV1OKxiTz");
            sb.Append("cY+bpCVhUvrC5cK95z3nvQ9XiyVyV4EFYIZgtYECsJyxra3ByxDwYOH27OxcdBrpncrR1nE9s7S+ez9b3DwPPB9soAMX56LT+AK+As8HRwmOL3Q8hREOMX/5HMCloHih");
            sb.Append("3iQR8JQgIoiAEkEJgOI4hQBN00AJSNdU3W6Mv12tz/w6aEW0oxepeDJ/t+trAmkgHQI6jqPGImNhGk2FiPDu09fonRsXzgRwMbpcJkrru0+yxc0rOpB7vVzhy7c9zpph");
            sb.Append("piIG3/ebp0/I5Zqesa3Fz7Wfz15ky3v7fzt8WNvB9VQfF08pfF9wfYXrC453xEUHyNhWCWit1X+TKlRcoD3IpQdVKUEpYUTXAMI6QDyZPwVMLuUrDvAIaDqOwhwd6WsS");
            sb.Append("0jVGwzqTpoHrK4CO3k1iAmXgYca2akAqvbJBdbtxyGUqYuC6Hn/+dXhTrGEvfWwBrzSRQ859iifz94DFl49vja9u/CBVqAhQB1rAe+BpxrYOuh8neMUSuWqhvCWxRK4d");
            sb.Append("S+SuB9Ucl8AEdgADuJmxrXJQnc5wTQArwPwwMzA8wUn1H+DSNPT2LId8AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0");
            sb.Append("RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwNjo1MzowMC0wNzowMPVeln0AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTM6MDAtMDc6MDCEAy7BAAAA");
            sb.Append("YnRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMv");
            sb.Append("YnkvMi41L4uGPGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NTE6MTAtMDc6MDApaOuNAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccll");
            sb.Append("PAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3Np");
            sb.Append("bGsvwsQNDQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property InsertComments_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void InsertComments_Reset()
        {
            _InsertComments = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití InsertComments_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _InsertComments = null;
        #endregion
        #region Image KSirtet
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku ksirtet.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu KSirtet_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property KSirtet, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property KSirtet_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet_Cached
		{
			get
			{
				if (_KSirtet == null) _KSirtet = KSirtet;
				return _KSirtet;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku ksirtet.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image KSirtet_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití KSirtet_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property KSirtet_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet { get { return _ImageCreateFrom(_KSirtet_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru ksirtet.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití KSirtet_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property KSirtet_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet_FromFile { get { return _ImageCreateFrom(_KSirtet_string, "ksirtet.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru KSirtet
		/// </summary>
		/// <returns></returns>
		private static string _KSirtet_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1712);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
			sb.Append("NUlEQVQ4y02TS0xcVQCGv3PunZk7Q2cYxgrSCkyxRDAUVPqwxYU2TUy0ddOoi0qaYB/uJEZd+KwmRmvUVFFjfDVuTNRNo0kTTU1TrZWiWHmJUMBS6JDhMQ7DPO6dO/cc");
			sb.Append("F0y03/7/8y3+X9QbgmZP89jDe5ldWuXc/AIyMcMdEZu3677GSWRxrs6BTocJBRqiGxtGshGJRCAASRkNKKXxlEJ5Ck9plKcoOi6oAgefP3D5yTeODttZe7fneqA16HLB");
			sb.Append("Wljhui6FvN2dL9gtRVvjFBz0Sr728Xe7deu2eE1NfZiuN4/+oF3vGa0ABKbSGg9w3RLZfOGVLz/ufcG7Ns6rR56+xQ1lKp74tHsoEnC5mnZYLsB3wzlk1LJkMIQ0DExX");
			sb.Append("gQ3kC85Xh3uOPJSbusT6fILGng+murceQvlKXMuDsoJcnHNYnv7rWS7MveZQBaYfMwu8eHD/xG2dO5rys39SSi1wTDzK4tZ9VBmQzPmwjSCVQWjfFSYjdscWbzpOxf3f");
			sb.Append("w0cgD1X69q9LTjZlRvuxihkqSykiEZOlAIwVoa7xczq2vM6EhpFVuO/Bkadefik9mUuBmwXjgYiqayHZpVMJQipN9XqLfbnTTK9UU7znHIe3naH5hiQ6MI4VSNMV/5D2");
			sb.Append("GztjbU3WsdOfTL5lmHmmOqupaqwt3hUSJQKpCWRlmD0V4zRafYzeuownitwcmqOlqo+Uspl3B3j/j0sk3eKwaQBS0jOdVIPbO5zPCMZhQxSvvpbtXge+CxcZ2jWIshwc");
			sb.Append("CuCanPyxgpGZLCwyZQpACjDg5M+p2OWdezb9JLNFjM2bUTVh7FgzceKYzLDCFd7pt/l7cQFrigO2ya9SlJcoBfjQ588upjcUNm7yOHOKsUiYVquH23kEVDu9v6VJLC3g");
			sb.Append("jNFm+PgCed2UBWAgCEg5//ton/lPMDJ7Yu45TBrIEeXERC+l1Yw9P0jM9DMspQABpiiHAYQAU0oCPj/HvzlfP3QnQ+/l7t6C6yKXGB0YoNXyg6tBKAFoTANA/W8hhMBn");
			sb.Append("SNb5ffQPuW33hid+MRXy22F2RP1gaPAU/2H6AFkCsXautYuWS/DDqSv5nXoFgn4w1XW6Zf4FIPlotXDlMh4AAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMjhUMTc6");
			sb.Append("MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA4OjQyOjEwLTA3OjAw7V4urQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQw");
			sb.Append("ODo0MjoxMC0wNzowMJwDlhEAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5");
			sb.Append("LWRhdGUAMjAwOS0xMS0yOFQxNDozMToxNy0wNzowMA9UTdcAAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly9l");
			sb.Append("dmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property KSirtet_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void KSirtet_Reset()
		{
			_KSirtet = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití KSirtet_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _KSirtet = null;
		#endregion
		#region Image MemoryRom
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku memory-rom.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MemoryRom_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MemoryRom, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MemoryRom_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom_Cached
        {
            get
            {
                if (_MemoryRom == null) _MemoryRom = MemoryRom;
                return _MemoryRom;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku memory-rom.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MemoryRom_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MemoryRom_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MemoryRom_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom { get { return _ImageCreateFrom(_MemoryRom_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru memory-rom.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MemoryRom_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MemoryRom_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom_FromFile { get { return _ImageCreateFrom(_MemoryRom_string, "memory-rom.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MemoryRom
        /// </summary>
        /// <returns></returns>
        private static string _MemoryRom_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1608);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAhWAAAIVgHhrxhDAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("+ElEQVQ4y5WTz2/bZBjHv/6R+PXqJE7SNE6bNIdtKoV2k7ouLVRFXDhw4MwfgcQfsAs3xIkDCIkrEvwFk0AgDhyQNm0SK1ppQ1CdpGkc55eT2I4d+439cpgGE0yT+J6e");
            sb.Append("0+f7SM/nEfBCOI5DobAGz5vzAPi9/X2WyaQQxwy+7+Nl4Z4PhBAsFguOA7T8auGY53llPncfx3Fk+f6iD2D5KgDPc9xavlA4Lq1vfLBRLh9LkpTwPPcyIQrd06enX7Vb");
            sb.Append("7Z8A/GcNEQBWVpRqpVq9t1mtvlfZ3Cxtb2/zmXQaV0Y3O7FGO4PBMJXLZe9MJ9P7zWbr10QiwSil/wDUrHr9jZ2d9yvValGWZaxrGjJqBoqiwDBSQhDQI1Hgar8/Pb1t");
            sb.Append("GL2PgyDQGWMux3EQAfBEklbzuWwyn83C833UGw2UyxtQMxlsv7YFrVjkz+rnUoLI7+zd3f8CcfxA07RvAJyJAMjO7uu3agd3lIk1QxgEYIyh2WpDlgnK6+soaSUkkxLE");
            sb.Append("pKRm86tvy1Ki5jhO1O/3PxEBsMJagVfVFP/wwUMQeQWVShVBGMKbe6j/0cCF3sTFhf7snJ4He7ZMLpfLFQAcDyByHdeezew4lVJQq+1BFBhzHYcRQhDHMQzDQBRHEAUB");
            sb.Append("DAyUhqCULgEwEcCy0fjzRJJJg0jSFpEl8fGjR/5s5sR3D99UBEGARAgWiwBRFMG17fnUGl+6jn0CIBAAMNPsd1rNdv3aNTlz48b1m+fndf7W7V1ha+umoDdb8Dwfjusw");
            sb.Append("0+i2u1edLwem+dncmf/CwHwBAEolbTkajfR0Oj3xfX93PLaUo6O3yGAwoD9+/8OZbdvL0WB43ul0Ph2Y5te5XF4HWEApfeZBr2cCADt58tvP+kXzw1JJe5fS8KPpZMI1");
            sb.Append("df1zSqMxY7Hhuu4TQRTpcDj420ThRS2LWjE6PDy46vXMYSql7I9HltJuX35rWdZ3YRh2CSExDcOXP9O/FS+XNw44nt+dTib3Hcft4v9EVdXn8MQrSgAAfwGOr2ptbwqJ");
            sb.Append("BAAAAA10RVh0QXV0aG9yAG1pbW9vaA6yENgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjNUMTY6MzY6MjItMDc6MDDEG5gWAAAAJXRFWHRkYXRlOm1vZGlmeQAy");
            sb.Append("MDEwLTAyLTIzVDE2OjM2OjIyLTA3OjAwtUYgqgAAADJ0RVh0TGljZW5zZQBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1B1YmxpY19kb21haW4//erPAAAAGXRF");
            sb.Append("WHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABx0RVh0U291cmNlAE9wZW4gQ2xpcCBBcnQgTGlicmFyeZjHSPcAAAAhdEVYdFNvdXJjZV9VUkwAaHR0cDov");
            sb.Append("L29wZW5jbGlwYXJ0Lm9yZ0W2VHAAAAAKdEVYdFRpdGxlAGNoaXABMT/aAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MemoryRom_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MemoryRom_Reset()
        {
            _MemoryRom = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MemoryRom_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MemoryRom = null;
        #endregion
        #region Image MailMarkImportant1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MailMarkImportant1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MailMarkImportant1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MailMarkImportant1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1_Cached
        {
            get
            {
                if (_MailMarkImportant1 == null) _MailMarkImportant1 = MailMarkImportant1;
                return _MailMarkImportant1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MailMarkImportant1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1 { get { return _ImageCreateFrom(_MailMarkImportant1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mail-mark-important.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1_FromFile { get { return _ImageCreateFrom(_MailMarkImportant1_string, "mail-mark-important.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MailMarkImportant1
        /// </summary>
        /// <returns></returns>
        private static string _MailMarkImportant1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1236);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("1klEQVQ4y5WSTWsTURSGnzsfmYkl0LTWIokO1oUtCG4URVARupDij6hQ/0I3XXTVTUURxG66kiBuAmGM/QdddqGIWMQ/IEwpVZvOzP1yMZNoaiHkwOHCy31ezj33FYxR");
            sb.Append("e2BPa944BgAL6+tgDBjD140NnHENyDLydhvStJhg8/nmY1fQkkpOjoRX17AlaLOsMDBavll+8nRy5vwMWmuEEAghsNZibfHk4rR8Wl2DEuwbOcaYqTAI6H54j+u6AEiZ");
            sb.Append("I2VOnudkWUqWpaTpyRDYN3Icx+HcxARzc1eJux0cx0EIB6Vk2QqlJJ7nD4GDCQCEEDQbDaLoCnG3g+/7eJ6PUgqtFUEQEobVsycoVHA9l2azwYXZWTpxmyAIqdenqNen");
            sb.Append("CcMqnbg9AJ0oGhh5/SUprcjSE6zV3Lp5h7fvWvi+X+5E8uD+Q34A33Z2/g+SxdI7/s3h0SF3b9+j1ztm6dHS0MVKpULTWj5/+UitVqNx8TIvXj4rDYxFa8P1hRv8/HWE");
            sb.Append("0RqEKNHiK3OZs19qB2UvAp7newdaq+lLzQgpc6rlsv6iZ0Q5z7FJwv72Np4xYvn11quW0mpkEhf7UY5j3Pl5AMQo6N/aA3ttZQWbJJgk4fvu7vgGp7U/1frhk1oaaVkA");
            sb.Append("AAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDYtMDc6MDAeMafSAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjA4OjQxLTA3OjAweaQR");
            sb.Append("swAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOTowODo0MS0wNzowMAj5qQ8AAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGlj");
            sb.Append("ZW5zZXMvR1BMLzIuMC9sagaoAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjA2LTA3OjAwQYDR5gAAABd0RVh0U291cmNlAEdOT01FIEljb24gVGhl");
            sb.Append("bWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MailMarkImportant1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MailMarkImportant1_Reset()
        {
            _MailMarkImportant1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MailMarkImportant1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MailMarkImportant1 = null;
        #endregion
        #region Image MailMarkImportant2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MailMarkImportant2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MailMarkImportant2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MailMarkImportant2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2_Cached
        {
            get
            {
                if (_MailMarkImportant2 == null) _MailMarkImportant2 = MailMarkImportant2;
                return _MailMarkImportant2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MailMarkImportant2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2 { get { return _ImageCreateFrom(_MailMarkImportant2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mail-mark-important-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2_FromFile { get { return _ImageCreateFrom(_MailMarkImportant2_string, "mail-mark-important-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MailMarkImportant2
        /// </summary>
        /// <returns></returns>
        private static string _MailMarkImportant2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1568);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("c0lEQVQ4y2WTT09TQRTFf/fNAC22pRQMSihGwCjsNHEhMUS2xuiKsEJTTFzDF5DgBzCydSGJrvAzqGCIce0C6gJU/giI9LXyr5Q3742L92gJ3ORkZnLvOefOnYxYazkd");
            sb.Append("c1qlgTGBQSAjITaAGYGZu8ZfO10vJwJzWmmB57Fsx3jHyONEY18vOpnAegav4HK0+outt+/s8fr65B3PnzwnMK/Vm/aRkVzLg/tgfKznYY3BGhOejUHq6tid/8zOzPtp");
            sb.Append("sM9ue4FxAL5oNXF5aCjXcm8Av1gMUSrRNPKEdO4ppujil1y8rd/Er/XQ+uhhTgnPAfTXOpVt7MxONPX34xWKVdfD/X1Svg/A/tYmca0hytW3tRHr7Bz/Vu+81A4MJ2/d");
            sb.Append("FN8tYI0HxoAxHLhFjDGhwPY29fF47SrGcOFGb2JvdXVMK+xwQ6YFv+iGDr4fChR28KMODv7u0JxMVDuwvkGlkihhUCuhPdjbxVaOqu4Yw1GhUBNwXQLjRQP1EN+gmtM4");
            sb.Append("2Ix2wK3k8+0q1oBojaM1iOAflqsC5vAAFIi1yHGF4PiYw08fUUJGK3C9/AIeIBHA4lmqM2B5Cc8Bkejta9jQSpgFO1Ajh+tF4EPHJQD6HFBnyNF+Rr7XkxZYEUhB6CJA");
            sb.Append("0ULb0ioAf3o6aZUzZMECV5zrFVtyhClHQhcFOEBCIAgCgiAgEeUciQxClcls2a6JtZafMdECrwVy0pRCZ1pxUkmIxRGlsYEPlQp29x/mxzLAdLZsRwE0wNUja4DRtbis");
            sb.Append("sLc3QVNadFc3uqsbicUINjfx8otUFhd2gSngxbnPdBJrcckCwxHaATfCLPAqW7al0/X/AYaVOw8S+wQMAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAy");
            sb.Append("OjM0LTA3OjAwtueOEgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNy0wNzowMJGkTagAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6");
            sb.Append("MjQ6NDEtMDc6MDBKqfBAAAAAZ3RFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZl");
            sb.Append("Y29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvW488YwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0wMy0xOVQxMDo1Mjo1MS0wNjowMH9o/QYAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRTb3VyY2UAT3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29u");
            sb.Append("cy5vcmcv7zeqywAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MailMarkImportant2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MailMarkImportant2_Reset()
        {
            _MailMarkImportant2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MailMarkImportant2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MailMarkImportant2 = null;
        #endregion
        #region Image MediaPlaybackStart3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStart3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStart3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStart3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart3_Cached
        {
            get
            {
                if (_MediaPlaybackStart3 == null) _MediaPlaybackStart3 = MediaPlaybackStart3;
                return _MediaPlaybackStart3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStart3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart3 { get { return _ImageCreateFrom(_MediaPlaybackStart3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-start-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart3_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStart3_string, "media-playback-start-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStart3
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStart3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1272);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("8UlEQVQ4y83SP2gTcRQH8O/vcsmludwvBpPmkusZQbigg7ZLipChSqyugptDEdRY6BDsYkc7CNKhtoMVSwRBRAvxzyAa2yEmTUFpPDtqQLykIcU6iOAlepqfU0JJLBVd");
            sb.Append("fPCDt7wPj/f7Av9Yti19EMBuAAzA978B5OHj8ffh8B4vEThD26c1qtXqtz8GJEnyq2rf2MXx8f718vppzsY1BqODn6PRaEPX9W03Iq0mEokcDO9V1zLPFlGplJF+mLay");
            sb.Append("2ew7ubd3WtP2r7rd7lIikTA7Aa59gGDQAQDlioHllRyOxeP2memZAz09rrk3a/oVQRBO5vP5Q6VSSfgtoCiKAAC8jYfoElHbqGHz0ya5NDFhTyaTJ3K5FzeXlp6PiaJ4");
            sb.Append("ijGmdQGBQMABADzPQ6IeUInC6XTCNE2ofSqXSt1yGWXj7KPHD4YAHO4CZFkWWgCldMvzoLZRa46OJuoD/QO3z5+7sALgZWuO77wBz9vhoR54d3lh1uuYmrpqNRkrTE5e");
            sb.Append("Tvv9chGATghpdAGhUEgAAEoprB8WFhbuW6+LRWNk5MydWCyWB7BKCPnS+QttQFEUBwAUCss/525c/zp05Ojd+fnUEwCvCCEft8tB1waZxczTa7Oz93xeX4EQ8mGnJLaD");
            sb.Append("xBgbBuADoAN4Swhp7jT8f9QvpKGaNS99JWcAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDYtMDc6MDAeMafSAAAAJXRFWHRkYXRlOmNyZWF0ZQAy");
            sb.Append("MDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOTowODo0Mi0wNzowMDkRs5IAAAA0dEVYdExpY2Vuc2UAaHR0");
            sb.Append("cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvR1BMLzIuMC9sagaoAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjA2LTA3OjAwQYDR5gAA");
            sb.Append("ABd0RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStart3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStart3_Reset()
        {
            _MediaPlaybackStart3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStart3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStart3 = null;
        #endregion
        #region Image MediaPlaybackPause3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackPause3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackPause3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackPause3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause3_Cached
        {
            get
            {
                if (_MediaPlaybackPause3 == null) _MediaPlaybackPause3 = MediaPlaybackPause3;
                return _MediaPlaybackPause3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackPause3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause3 { get { return _ImageCreateFrom(_MediaPlaybackPause3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-pause-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause3_FromFile { get { return _ImageCreateFrom(_MediaPlaybackPause3_string, "media-playback-pause-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackPause3
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackPause3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(936);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAA");
            sb.Append("9UlEQVQ4y9XSPU7DMBjG8b8/5BBkS60nhpBISY7AKRDiFFTlNJSoPQlCnIKZj64sTKxhM1OiOK5EN8Qzvf7p9SMPhr+OmMweODnizjfwNRz0MOR5fnp1ffkx3Xx8eDo/");
            sb.Append("ZH3fjwVyGNq2NQDbbse220V2v+nY3HWRJQVlWWYASile314i2+/fUUpGlhTUdW0ApFRY6yKz1qGUjiwpqKrKACitcM5G5pxFaxXZoRdkAFIIjMkiMyZDChlZUtA0jQEI");
            sb.Append("ITC3qU8tKiiKYizwSx/ZYrEkzPaSf+C91wCr9Q1zW9+uEhsy/sQQwgVwxu/5FEI8H7H3X/IDQ4M140VQSTMAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMjM6");
            sb.Append("MDQ6MDYtMDc6MDAeMafSAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQw");
            sb.Append("OTowODo0MS0wNzowMAj5qQ8AAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvR1BMLzIuMC9sagaoAAAAJXRFWHRtb2RpZnkt");
            sb.Append("ZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjA2LTA3OjAwQYDR5gAAABd0RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9h");
            sb.Append("cnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackPause3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackPause3_Reset()
        {
            _MediaPlaybackPause3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackPause3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackPause3 = null;
        #endregion
        #region Image MediaPlaybackStop3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStop3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStop3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStop3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop3_Cached
        {
            get
            {
                if (_MediaPlaybackStop3 == null) _MediaPlaybackStop3 = MediaPlaybackStop3;
                return _MediaPlaybackStop3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStop3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop3 { get { return _ImageCreateFrom(_MediaPlaybackStop3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-stop-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-3.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop3_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStop3_string, "media-playback-stop-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStop3
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStop3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(972);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("EElEQVQ4y9WSMUrEQBSGv/dmyJpMl8YUMYHdVGrpKUQ8hWKneA/1MCKeQdEuRxCWsIXt2o3FbIaEiLud+JjHzMD/f/MPPPjrksE5B/Z28HwBn/3F9oc0TbOz89OPbe6n");
            sb.Append("x+eD9Xo9BTRNkwDc3z0gIghCWCGkiHBze03TNEnbtkwAVVXNAFSU17cXrLVYY8NuLUeHx1H3I2A+nyfdaomo4JyLZrMBqDFRN/xSBNR1nXSrJaqKy1x82fSgDaCu6xFA");
            sb.Append("BwlmAEYNmXNkWWjnQhvVkW6SYLFYJADGmJhANfLx3o90E0BZlhFQ7Bf44ArmTQ91E0Ce5xbg8uri1znodX3FSfTenwDFtkECOhF530H3X+obx9IwzmNsmPEAAAAldEVY");
            sb.Append("dGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMjM6MDQ6MDUtMDc6MDAv2b1PAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0");
            sb.Append("RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOTowODozNi0wNzowMMebnpgAAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMv");
            sb.Append("R1BMLzIuMC9sagaoAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjA1LTA3OjAwcGjLewAAABd0RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZp");
            sb.Append("AAAAIHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStop3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStop3_Reset()
        {
            _MediaPlaybackStop3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStop3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStop3 = null;
        #endregion
        #region Image MediaPlaybackStart4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStart4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStart4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStart4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart4_Cached
        {
            get
            {
                if (_MediaPlaybackStart4 == null) _MediaPlaybackStart4 = MediaPlaybackStart4;
                return _MediaPlaybackStart4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStart4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart4 { get { return _ImageCreateFrom(_MediaPlaybackStart4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-start-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-start-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart4_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStart4_string, "media-playback-start-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStart4
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStart4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(856);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAXdEVYdFNvdXJj");
            sb.Append("ZQBHTk9NRSBJY29uIFRoZW1lwfkmaQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAABzUlEQVQ4T2NgEGZgoAgjaZYEsuWBmA+IGYk2FEmhCl+9");
            sb.Append("6H/eSpHprEGculyZAiCDCLsOpohJg1kdZEDc46Lfgr1S7/nqxcpEp8trSy5U4cVrEEySLZBbD2TAyf/P/8/+uuW/2Rm3X0CDrkgvV0s2Oemqb3cpgAurQTBBnjIRE5AB");
            sb.Append("s75u/u99O/p/24c5/2d82fhPYYPOL/G5iltdr0VE571s1Z/4aRU7ikEwjthMBWuQAQu+7fwf8TDzf8qz8v+Vbyb8X/J93/+at5P/Ar3yVXOf+eyF3/ZEA12pBjcExlDc");
            sb.Append("pO8IMmDZ9wP/M57X/i9/0/2/FeiKqV/W/V/+4yDYaxILlP7bXPCeDWTHYxhgeNzJA2TAmp/H/le/nfi/++NCsHdWA/lN72f+lVmh/s38jNuCI/8eJgIN0MAwwONGtB/I");
            sb.Append("gE2/zv+f+Hnl/9U/jgIDc9t/lR2Gv5S3G+xf/mNfDlCjJRBzYA2DtGe1obBYANlqc8Hnl9QSldvAgKsHanICYuzpAmZaz8dl0SADCl62/hGbJf/R4UrwdKAmHyAWIyod");
            sb.Append("bPl1MQlkgMY+s80rfx4FhbQCSSkRqMENiKOAWBOImYjSDErqRCvElS8oNQAAweL7oTzWkYcAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStart4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStart4_Reset()
        {
            _MediaPlaybackStart4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStart4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStart4 = null;
        #endregion
        #region Image MediaPlaybackPause4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackPause4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackPause4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackPause4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause4_Cached
        {
            get
            {
                if (_MediaPlaybackPause4 == null) _MediaPlaybackPause4 = MediaPlaybackPause4;
                return _MediaPlaybackPause4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackPause4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause4 { get { return _ImageCreateFrom(_MediaPlaybackPause4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-pause-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-pause-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause4_FromFile { get { return _ImageCreateFrom(_MediaPlaybackPause4_string, "media-playback-pause-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackPause4
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackPause4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(540);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABd0RVh0U291cmNlAEdOT01FIEljb24g");
            sb.Append("VGhlbWXB+SZpAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAADuSURBVDhPY2AYTEAI6BgpIjBIHRbALCDDpdr7Hxkz4BDDboBAoBJI8/nL38EY");
            sb.Append("xGaAip08/+3/8bPf4GJYDWCTa9QEabp648f/xr7nYMUwMRD/LNRQkBhWA8SN1+qDNN268/P/9IVvwQbAxED8y0CDYWJYDTDxO2kKUvDgya//G7Z/BCuGiYH4dx78hIth");
            sb.Append("NSCl5IENSNOTZ7/+7z70BawYJgbiP3j0Cy6G1YBFqz44gTQ9AroAZgBMDMS/B3UBSAyrAUC/e4C9ALQJZhtMDOR8mBdAYlgN+P//vw96OsAlhssAE5AGIrDJYMo+VHAL");
            sb.Append("AGB6AG/YbLJVAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackPause4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackPause4_Reset()
        {
            _MediaPlaybackPause4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackPause4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackPause4 = null;
        #endregion
        #region Image MediaPlaybackStop4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStop4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStop4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStop4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop4_Cached
        {
            get
            {
                if (_MediaPlaybackStop4 == null) _MediaPlaybackStop4 = MediaPlaybackStop4;
                return _MediaPlaybackStop4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStop4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop4 { get { return _ImageCreateFrom(_MediaPlaybackStop4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-stop-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\media-playback-stop-4.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop4_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStop4_string, "media-playback-stop-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStop4
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStop4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(672);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAXdEVYdFNvdXJj");
            sb.Append("ZQBHTk9NRSBJY29uIFRoZW1lwfkmaQAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAABRElEQVQ4T2OQY2BgoARTpBlkMbIBQkABKSIwSB1cH5xh");
            sb.Append("wMAos5lf7j8hDFKH1YByVm4lkOa/DWv+/21cB8Tr//9tAuENENy8EWw4SB1WA5bxSGqCDQBq/Oye+/+Ld+H/r35l/78FVf3/Hlb//2/bFrABIHVYDTgrYagPNqB5A1BT");
            sb.Append("5f/voXX/f0Q2//8R1/7/Z1LP/7+d28EGgNRhNeCJlq8p2IC2zf9/xLb9/5nY/f9Xav//X5lT/v/Onfn/b+9usAEgdVgN+OxWYAM2oGMbUNPk/79zZvz/XTj3/5/Shf//");
            sb.Append("VC37/69/H9gAkDqsBvzOnukENqBn1/8/JQv+/6lc+v9P9XI4/te3B2wASB1WA/727PYAKQDZBMdATSCNf6EYYsFuD6wG/F90yYdQGgDJg9ThMsAEJEkENsFqALkZiqqZ");
            sb.Append("iSzDACyaHwDvfdNjAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStop4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStop4_Reset()
        {
            _MediaPlaybackStop4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStop4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStop4 = null;
        #endregion
        #region Image MediaPlaybackStart5
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-5.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStart5_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStart5, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStart5_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-start-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart5_Cached
        {
            get
            {
                if (_MediaPlaybackStart5 == null) _MediaPlaybackStart5 = MediaPlaybackStart5;
                return _MediaPlaybackStart5;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-start-5.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStart5_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-start-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart5 { get { return _ImageCreateFrom(_MediaPlaybackStart5_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-start-5.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStart5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStart5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-start-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStart5_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStart5_string, "media-playback-start-5.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStart5
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStart5_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1592);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAqBJREFUOMuFk01vE1cUhp9zz50ZD6RqQQiogHywcFu+oSpNiFgB6qYrkNombNuf4XUXqK2QWLMACbEBIYFAYoG6QURtqvIV4iCIQU0cEsf2");
            sb.Append("eOLEji3P7WIsAgjBu733POc9r86RrccvvAxVFgoTpV8J9CZGmngGXAIO8BXaCeBAHFiFTpK++z46/N3PZy6eObHd7/F/zL+oDTWrjRZWJhEcAqiBxAGAAMaAcylQFd26");
            sb.Append("dyT3y+m9OvztDo4O9e+06/2ThZn4+GrcKJEkBXybfBCwZd9o7sDhrD6YBQlDhgZ75cjgQG+iOjK/uDzcrDUjROYQVt8L2LRnNLfncFYLVZipwPQiJGHI/kN97D/YP6CB");
            sb.Append("98N8KR5sxysxuKdYdW8BPts1mus7kNXpCkRNiFtQrMF/VWhnQnbu7jVf7hsYcNaerFXrx9rLzRLOFTHSRhXt+Wo0t+GLrD4vQ9ToQlah2oRXMbwsQ6wh23b16bZsb7+z");
            sb.Append("dqReXfq6s7xSw/MKsv3U9dY3P33vvaiAJCDC2xJIEkiAMISeAFbKEYXxJ635xxN3beKg3VkL+X0SASX9F7WgIx7Gtz4iGSuAGPAUjL5R5dYcqAdqYWkxYu5hnvJk/l67");
            sb.Append("XDlHJnPFWgOfroOOI/Up3aUz4GVSaG1hiel7jzrF+1P/rkbx7xhu4nk1RLBGYUNP2sElaVM/AGuhNFdjaizvno/n/27Ml8+hchnPayPdYJzDGgOfrINMkK65DaA0W+ef");
            sb.Append("W4+ZHMuP1xeis3j2NkGwgOt0HbrXk1pV+HxzGtRMIebujSn3150nD+pzlT8Qd5XQr4NZs/eO7PqMCs0Gt69N8OeNibF4tnoej0t4dhlxfEyy8djFYibQavFZ6Tecu4pq");
            sb.Append("tFbowBpeO3BJep2uO4Yq/wOgsSbhszZGGgAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjowODo0MS0wNzowMCSu4eAAAAAldEVYdGRhdGU6Y3JlYXRlADIw");
            sb.Append("MTAtMDItMjBUMjM6MjY6MTctMDc6MDCRpE2oAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjE4OjM5LTA3OjAw8F0xsQAAADV0RVh0TGljZW5zZQBodHRw");
            sb.Append("Oi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwex+X1AAA");
            sb.Append("ABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXxAAAANHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuaWNvbi1r");
            sb.Append("aW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStart5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStart5_Reset()
        {
            _MediaPlaybackStart5 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStart5_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStart5 = null;
        #endregion
        #region Image MediaPlaybackPause5
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-5.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackPause5_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackPause5, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackPause5_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-pause-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause5_Cached
        {
            get
            {
                if (_MediaPlaybackPause5 == null) _MediaPlaybackPause5 = MediaPlaybackPause5;
                return _MediaPlaybackPause5;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-pause-5.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackPause5_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-pause-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause5 { get { return _ImageCreateFrom(_MediaPlaybackPause5_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-pause-5.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackPause5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackPause5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-pause-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackPause5_FromFile { get { return _ImageCreateFrom(_MediaPlaybackPause5_string, "media-playback-pause-5.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackPause5
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackPause5_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1380);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAgFJREFUOMulkr9qVFEQxn9zztzduywxiVlCEl2DRXwBY2UXfQo7sRJBX8LKJg+gjZWNnZWCoIVYBFREUJAEY4ibGM2ue3H/3XvPWNwbs8Y/");
            sb.Append("jQPDGTjf+b5vzozMXbi7sXJ2oWFmwQnsJ6P647XtO6NeehUnIAJmuMivriwvXJubrvWzEMx755682unomcXp5urNi5oHiBTevGvz/PL9xVGnD5EHcZAH9Fh8+vqV5ej8");
            sb.Append("ufloMIQ4hks3HtY0GZqtbUHIQRXWPxuZkaOABwQAAqRv90A3IU2hUoX2ANPuCF60wAJ4B609IwdwYylgDt7vG2kL8gw0gu4ANEnh9W4h4Ty0v0JupfoBAWAC6/vQ3S0I");
            sb.Append("fATdEegwg4+dwoE46CWQy6/qB23sJPC9AyEDr9AfgRpghQFk7PwZJYFJgRvH26HBQyEpL/4V41jHf4YyZuuglr+Aj7ZrgArF+ADEl7X9OdWBegjlyEVAqwrzk2BWEHwb");
            sb.Append("gJPfHwtwfAIak5DnxRQ+VEqCEzOHrNV++TH5WC+hOBoTcHKm2ESNIFbQOIJmAywvFkl7RxyEgkwCzE5CcwayFKIK1CqgtdjJUrNYDo1ARx5neNJS3ZUEZlFz1rF0CrIh");
            sb.Append("RDHUYxH9tNVu3b71dMqM4AS6ybA+hG2maqUVwIygbuvBvZfZs0f1XsiDOe9kc+NL8gMGhNtQ1at6dgAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjowODo0");
            sb.Append("MS0wNzowMCSu4eAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTctMDc6MDCRpE2oAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjE4");
            sb.Append("OjQwLTA3OjAwbwB9ewAAADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0");
            sb.Append("ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwex+X1AAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXxAAAA");
            sb.Append("NHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuaWNvbi1raW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackPause5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackPause5_Reset()
        {
            _MediaPlaybackPause5 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackPause5_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackPause5 = null;
        #endregion
        #region Image MediaPlaybackStop5
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-5.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MediaPlaybackStop5_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MediaPlaybackStop5, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MediaPlaybackStop5_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-stop-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop5_Cached
        {
            get
            {
                if (_MediaPlaybackStop5 == null) _MediaPlaybackStop5 = MediaPlaybackStop5;
                return _MediaPlaybackStop5;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku media-playback-stop-5.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MediaPlaybackStop5_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-stop-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop5 { get { return _ImageCreateFrom(_MediaPlaybackStop5_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru media-playback-stop-5.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MediaPlaybackStop5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MediaPlaybackStop5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\media-playback-stop-5.png
        /// </remarks>
        public static System.Drawing.Image MediaPlaybackStop5_FromFile { get { return _ImageCreateFrom(_MediaPlaybackStop5_string, "media-playback-stop-5.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MediaPlaybackStop5
        /// </summary>
        /// <returns></returns>
        private static string _MediaPlaybackStop5_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAPdJREFUOMvFk01KA0EQhb+a6qSbbISg6Cp3yj3E4+gZcqpshBjyg8NAMnFmqlykZ6m0uvBBbYquj0fVa3kUeb2L8d5VHXeKJIKYyaFtj+F2");
            sb.Append("On14Wi41LRZY2xbNVzHS7XY8r1bzAFgVo+pshmf6t3JHU8JTAhEPbkazXnNpGrquK3IQJhO8rrG+J2DGZbtlOJ3o+74IoKrI+QxmBDej3Wxgv8cKlygi6DDAMBDEnY+6");
            sb.Append("xgEruwEVoPl9BSCFg1/B/qT/B4TfUKpcAgQBUm6UpeB6AR0BDtwAU6Ash1fbY2KCgKTs4ieAnAEJBzi+wFwo/sxjbuQN3j8BTDteK1z4BxwAAAAldEVYdGNyZWF0ZS1k");
            sb.Append("YXRlADIwMDktMTEtMTVUMTY6MDg6NDEtMDc6MDAkruHgAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0RVh0ZGF0ZTpt");
            sb.Append("b2RpZnkAMjAxMC0wMS0xMVQwOToxODozNC0wNzowMJGKUHEAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEv");
            sb.Append("O8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xNVQxNjowODo0MS0wNzowMHsfl9QAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAADXRF");
            sb.Append("WHRTb3VyY2UATnV2b2xhrE818QAAADR0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lmljb24ta2luZy5jb20vcHJvamVjdHMvbnV2b2xhL3Y9tFIAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MediaPlaybackStop5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MediaPlaybackStop5_Reset()
        {
            _MediaPlaybackStop5 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MediaPlaybackStop5_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MediaPlaybackStop5 = null;
        #endregion
        #region Image Warning_16
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Warning_16.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Warning_16_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Warning_16, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Warning_16_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Warning_16.png
		/// </remarks>
		public static System.Drawing.Image Warning_16_Cached
		{
			get
			{
				if (_Warning_16 == null) _Warning_16 = Warning_16;
				return _Warning_16;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Warning_16.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Warning_16_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Warning_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Warning_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Warning_16.png
		/// </remarks>
		public static System.Drawing.Image Warning_16 { get { return _ImageCreateFrom(_Warning_16_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru Warning_16.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Warning_16_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Warning_16_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pic16\Warning_16.png
		/// </remarks>
		public static System.Drawing.Image Warning_16_FromFile { get { return _ImageCreateFrom(_Warning_16_string, "Warning_16.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Warning_16
		/// </summary>
		/// <returns></returns>
		private static string _Warning_16_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(876);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAACV0lEQVR4nJ2STUhUYRSG33Pvde4dnT9HRy0yGa0sG1ExTYvM30QjIoqihaugTQ7RqhajqZtIidKKoCC1");
			sb.Append("FpGkZKtohMDsB0rNBnMih3E0MJiUEgadSe9poZaSP9TZfPCe933O+T4+YJ0qKz0qrOdZtVqaO8+0tT27/l/hs/aqSNdHj/+Txxu6fOl28mq+VdcrKCqsjrM8jDZpq8My");
			sb.Append("czLq/2l6XU1T8rB3MDjjN/DspMgeb7d688aD/JW84kqi42Jdy+ao1h1+/xQmvpmh4RFSoo+l/pzmOx9c79ae3tR4v2TU95JnfElsiY1jANz3NIm9wx18t7mzYs3wieOn");
			sb.Append("xDdvB12Trnyec2s5eaeNAfCXHit/703h1/3uUXulQ7s0s+wRy8sPn47XD9sixj8jOJgIsykcgiBC60uD5DYgLjQQn7sv79yKAHulw5i2K6VW6H2E0Ph2zAU2IFonwRRp");
			sb.Append("gkaaA4lG6Efbsc2WcN7huBL7F6CgqLAqarrPYpAnIOpkiHoZMWYFMVFGSOEEQa9ApwvBEugxZOZk1y7mRACoqW7cml+c1WoeuyVqFBWkSBBkCbI+BlmpCbBZVZAizmuz");
			sb.Append("Y+CE0nTrpoz2rq4nfgkA9uzPbTD8cGoiDLOAIAMCAUS40NQNj+8rTr6qANQAQASFCJZpp5S6e28DgIN07eq9orJD2c6NE/UkiSqIABIAEGHAo2IqoCIvTTO/LwEEAgMY");
			sb.Append("Uux44RwqoY7Hz/u3pCSmB4Mh8MK9Fs95EsBgqMzgJb0wWQPf0Mh7Kj1wRCaiBf7yn/lH/g0Wlwqsquov77LKG/O/y1kAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Warning_16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Warning_16_Reset()
		{
			_Warning_16 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Warning_16_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Warning_16 = null;
		#endregion
		#region Image LockBlue3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Lock-b3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu LockBlue3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property LockBlue3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LockBlue3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-b3.png
		/// </remarks>
		public static System.Drawing.Image LockBlue3_Cached
		{
			get
			{
				if (_LockBlue3 == null) _LockBlue3 = LockBlue3;
				return _LockBlue3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Lock-b3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image LockBlue3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockBlue3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property LockBlue3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-b3.png
		/// </remarks>
		public static System.Drawing.Image LockBlue3 { get { return _ImageCreateFrom(_LockBlue3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru Lock-b3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockBlue3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property LockBlue3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-b3.png
		/// </remarks>
		public static System.Drawing.Image LockBlue3_FromFile { get { return _ImageCreateFrom(_LockBlue3_string, "Lock-b3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru LockBlue3
		/// </summary>
		/// <returns></returns>
		private static string _LockBlue3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1724);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAwRJREFUOMtdk0tvG2UUhp/v89gznont2E5sl9DEveQihYsiQlXUqgKhCoQqsawKvwCVbfeg7hASIHXDD0BVJVZIZZMNErsiEZUKBLSkLeTi");
			sb.Append("2InteGY81+8bVjWkZ3UW53n0Ls4reH5Wb1Gulmg2qziOjUozRgOPw91DvMMBbP8IfDc5zz0P8+vHIkrfqPpKv+S549eG/dHK0cGwHOz1Qjq3QppXwd+YIOLZYqx9TTp0");
			sb.Append("i7V2661T7ea1ky/OnLcduxrFmoOeP9x52v1p/8nuHffvnY2caftq/8b/E1xHW3axuTx/9eKFlZtvX1p5c/FMsz5bK9rVim07lUrNma6vZtI8Nw6Tcdjr/UZ8NoHNZ4JX");
			sb.Append("ZG3t5csXL6zcvHxpZbnkFISFz6mqolVRaJWwP8qELFaqUWKsht54Kx08+QN+ySQAc0uV+YXmtfVX5xeLVgHfG9Mqw8+PY+79GbN4wsCSEf44wKzPLli1xgfCmp8BkADF");
			sb.Append("E7XT+XL9/CCxZbcfUCqklIsSKUBKKBUlS3N5wjDEj8YiZ5vrhjO9NBGYlvlCoM3q9/cDHu2OOdvK4Qaa9qzBmZbB0NO8vlikNqU4GPRJRVYWRr4BYACgtFCpFtu9iC0z");
			sb.Append("pXtk8s0PI0a+IggSclLz0ZU6BREThQG5NCVTmokg8aOO8r2haZVrWmcEsebBU5+9wxCdxNQdQRRNk+kUoTVqHHs6iHoTQdA7+MvvHdyz5yrtvLRksSCYq+cQmQRt0Cjl");
			sb.Append("sC2JAGSiMz10N1XgPpwI9N6jwdFM48606ZxLWidPayTX35shiBVkGQUDhJT0XQFDfyft92+jO/8lAEt7250NMvH540zd+GI02y4UhEiSGK1SRAbeKGX7984/erfzlTo6");
			sb.Append("vAuGOvbK+YUvSQZDx6rPvmNWqx8K21lXQpZ1mqKCyFVDd1P1+7f1qH9XFIpuFn9yvAsAND6D7rcC892ZfKm0LHL5Rqa00GHUVZ77EO53YV3DpxPEOCboPkBMv58VpqZ6");
			sb.Append("+alSj3yeLNWkfgAyh/bWyPTWMeRf3K1o+/2+YpEAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDB2ls5HAAAAJXRFWHRkYXRlOmNyZWF0");
			sb.Append("ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3OjAwkaRNqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToxODo0MS0wNzowMMl3ds8AAAA1dEVYdExpY2Vuc2UA");
			sb.Append("aHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xNVQxNjowODo0NC0wNzowMCkn");
			sb.Append("uHMAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAADXRFWHRTb3VyY2UATnV2b2xhrE818QAAADR0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lmlj");
			sb.Append("b24ta2luZy5jb20vcHJvamVjdHMvbnV2b2xhL3Y9tFIAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property LockBlue3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void LockBlue3_Reset()
		{
			_LockBlue3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití LockBlue3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _LockBlue3 = null;
		#endregion
		#region Image LockRed3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Lock-r3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu LockRed3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property LockRed3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LockRed3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-r3.png
		/// </remarks>
		public static System.Drawing.Image LockRed3_Cached
		{
			get
			{
				if (_LockRed3 == null) _LockRed3 = LockRed3;
				return _LockRed3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku Lock-r3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image LockRed3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockRed3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property LockRed3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-r3.png
		/// </remarks>
		public static System.Drawing.Image LockRed3 { get { return _ImageCreateFrom(_LockRed3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru Lock-r3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockRed3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property LockRed3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock-r3.png
		/// </remarks>
		public static System.Drawing.Image LockRed3_FromFile { get { return _ImageCreateFrom(_LockRed3_string, "Lock-r3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru LockRed3
		/// </summary>
		/// <returns></returns>
		private static string _LockRed3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1172);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAAA3dEVYdFNv");
			sb.Append("dXJjZQBOdXZvbGEgaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS/CFbEcAAACvElEQVQ4T7WTW0jTYRjG3/2dp83THPPAVlpuU/OwmRkqilmQ");
			sb.Append("IXhIIbIrL7pJKCpPlR0uMupCs2Y6j+gcMQwND828SqgIzRGERMq2xNNOTof/e33668WwEK/qg+/y+T3P+33PS/QfDk8nI9GYP52a4DNFRj9e8XAIZfTEUnisgHiH+g1I");
			sb.Append("KHDS16/QJE/QW/MLzPbCi27buUK3Va22fJVGGN6F+5R2yEl4IETPiacEQZWWMxfm2epH2+zDJrB3G8HeuAO24irYswU75rgYq1HMVLUr/4LUK4nZdd4TN2rAPtNis7kN");
			sb.Append("ztdvYBsYhLPhMbbOl4A9mQWzVLw4Ek3lN+OI8SbRSUlkilXq95ybe8E+eMqJh+C+dQ+uqtuwDxjgKLmEzfgUbEVG73yR8Ic1SRThBYz5UfqSXG1mK2vB1j/BRlMrXMZJ");
			sb.Append("uGsasH69FvYRI2x192GPUcAhFMMU6rekl1OOF/De16doXZrgZsVqsGWVcI1OwGUYgvNVFxwvO+Do08M+PIpFboSfxIfJn/EMHqMyL8Ao4Bc7I49vsBQJVpWH9W4d3LkF");
			sb.Append("cKsy4VCmYi0xDba2bsxn5eEbjzAdQB6DYh9gJIhOWyJk1j1ASg5cLzjXEBlWKQBW8oU5MByrzzWY4wCzDOFTKK3okinXm6BHRuIZUbBhUxi17Uk/C1eXDvakTCyFHYFF");
			sb.Append("dBTm+DSsansxl52HGX/aMcpoTKOiKC+gRkHMuIgp/RESbN1IzYZb2w9nZx9sLVrutmOtrQf2zn4sJCRhSkIr+gSqqFOQzx+F6okj4biId+27OOzXqjJ1ZyUpAxalGgty");
			sb.Append("FRYUKZiXyvBZxCwb4qm6JZVCDmxjh4KEb6Op7IOYPzwjYJZm/ckzLSDPxzBa5mKPDiTSZU4cfOg+5EuI155MEn0c5ex+Fffa5f0nKLeVm/mKbF/7/tUW/wZFO0+B76q8");
			sb.Append("wgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property LockRed3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void LockRed3_Reset()
		{
			_LockRed3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití LockRed3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _LockRed3 = null;
		#endregion
        #region Image Lock_r
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Lock_r.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Lock_r_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Lock_r, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Lock_r_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_r.png
        /// </remarks>
        public static System.Drawing.Image Lock_r_Cached
        {
            get
            {
                if (_Lock_r == null) _Lock_r = Lock_r;
                return _Lock_r;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Lock_r.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Lock_r_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Lock_r_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Lock_r_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_r.png
        /// </remarks>
        public static System.Drawing.Image Lock_r { get { return _ImageCreateFrom(_Lock_r_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru Lock_r.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Lock_r_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Lock_r_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_r.png
        /// </remarks>
        public static System.Drawing.Image Lock_r_FromFile { get { return _ImageCreateFrom(_Lock_r_string, "Lock_r.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Lock_r
        /// </summary>
        /// <returns></returns>
        private static string _Lock_r_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(928);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAACKElEQVQ4T5WSX2hScRTH75q2pUsbrLnblrKla5vYXLON5VrbIggqiFGE7kEoCkTsQTMm+AcuOhEfBHtQh6+JA1+yHoI9");
            sb.Append("rD9PgxEciN5661XosYe1b+dWbl3Nogtffr/f+X3P5/zO4QpC0+fxeNTZbFYqFouf0+n0figUQiAQqIfD4aLP5+tt9recc7lcuVaroVwu72UymY+c+CEYDH6NxWKQJGnX");
            sb.Append("7Xar20K8Xq+NE/er1eq3VCrlbBi5sjkajX5hIHh1tQX4/X5XpVJBqVR632yKRCLPZEAikUi2BXClVRmQz+e3mk3xePypDEgmk6l/AgqFwv8DXvfrrW9GTZvbt29ha3nh");
            sb.Append("E3UJcer+Jd6/nLTuPL+yiFd26/a7ft2E4hVPtEePUZ+uTpeXQfOLICdrbgk0swBysKacIPsl0Ll5kPUiSN1ZlzjnABLuEEw0OMwGNsoGWeNzoLFZ1gzIbAMNj4KM7DEa");
            sb.Append("QSf1WD8imJQAcQhkc3ClC7zaQQN92NRq8EIlgPSdnKQ9VE8HeJJNgPNc4Ro/d/wsyCCiqumC/fodTN+4i7dqFScPHErb/QfAFCdauPLIT+1oenHz/iOsrD4E6cSD+I/7");
            sb.Append("EyLWW15g4N7kfhsyjuGBbw3Rez5lXL5nbytg8BRokmfQ0BkLHq+4kFi6qozL90OnlYA1lSCS0QCa5QE25JjmeZhBEzyb3+Py3sQtqAVR8S9Qj7BBI4Y9snC/f5PsOS5s");
            sb.Append("NJK/A8LmX5L627p4AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Lock_r_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Lock_r_Reset()
        {
            _Lock_r = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Lock_r_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Lock_r = null;
        #endregion
        #region Image Lock_y
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Lock_y.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Lock_y_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Lock_y, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Lock_y_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_y.png
        /// </remarks>
        public static System.Drawing.Image Lock_y_Cached
        {
            get
            {
                if (_Lock_y == null) _Lock_y = Lock_y;
                return _Lock_y;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Lock_y.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Lock_y_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Lock_y_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Lock_y_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_y.png
        /// </remarks>
        public static System.Drawing.Image Lock_y { get { return _ImageCreateFrom(_Lock_y_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru Lock_y.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Lock_y_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Lock_y_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Lock_y.png
        /// </remarks>
        public static System.Drawing.Image Lock_y_FromFile { get { return _ImageCreateFrom(_Lock_y_string, "Lock_y.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Lock_y
        /// </summary>
        /// <returns></returns>
        private static string _Lock_y_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(836);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAACOklEQVR4nH2SwUtUQRzHP/PmvX1v3dXVjdbFFWMrL74NBCFCwg6duniIkMCbhFCIB/HgZc1j9CcEFV0j");
            sb.Append("KILoEHUoIuhUh0LSDENko+e2Eru2b3dmOuxq66p9YeA3P37zmd/vOyNo0/z8vDM6Oprv7OycCoKgr1AoiHq9XvQ871GpVFrI5/O/WuutdsDY2NgD3/fziUQiLaVcdhzn");
            sb.Append("kxAi5rrudCaTeTE7O+scCVhaWjqTTqevVqtVvbKycmFiYmJoZmYmV6lUclrr7VgsNuL7/pUjAY7j5KSUIgiCj5OTk29384uLi6vGmGcAnufljgRorS2AMAy32kezbbsI");
            sb.Append("IITYd+aAB82iw9KHyt4N1h4P+1bk1bhV2SYhtk7+ft570xEhAMYIVstPzio7hesG574/HR4aGP/wGUAA3LrRF527nN5wvJEkWoHWoDR7sVbNfSOuyeXi3Tfl/uu3N3Zs");
            sb.Append("AKv2IyX/DCapBI0iYxpLmMYVsg5SgaPBAiniSVn7mgLWmyMoEApcATIClkapTd4tF+lwywyfjmMJr8XtMhjV6oGA3h5wj8FWASpF3n/7ycLD89jS4v6112R7Olqsqx80");
            sb.Append("ESVgbQNqNSBKNuFyKnuCmFvluBOHnRaACJv2mV2AwRQCMEmwJQCpeIrBgW6S0YC429/2zu4hHUQdsFrmNHU8/YWIKkHcY590pA1gd4VENET+kYVxmLu03mhVdu87b0IN");
            sb.Append("TlcIJfa+3M7L7B3bzUwJS0r+I6OVUtXNe97FtWmAv0TVyxwPUnmWAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Lock_y_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Lock_y_Reset()
        {
            _Lock_y = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Lock_y_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Lock_y = null;
        #endregion
        #region Image Padlock_r
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Padlock_r.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Padlock_r_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Padlock_r, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Padlock_r_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_r.png
        /// </remarks>
        public static System.Drawing.Image Padlock_r_Cached
        {
            get
            {
                if (_Padlock_r == null) _Padlock_r = Padlock_r;
                return _Padlock_r;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Padlock_r.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Padlock_r_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Padlock_r_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Padlock_r_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_r.png
        /// </remarks>
        public static System.Drawing.Image Padlock_r { get { return _ImageCreateFrom(_Padlock_r_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru Padlock_r.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Padlock_r_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Padlock_r_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_r.png
        /// </remarks>
        public static System.Drawing.Image Padlock_r_FromFile { get { return _ImageCreateFrom(_Padlock_r_string, "Padlock_r.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Padlock_r
        /// </summary>
        /// <returns></returns>
        private static string _Padlock_r_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(992);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAACWElEQVQ4T42SXUhTYRjHjUkXBVLZB5QYrkznNjfXnPv+PDubx7mzuQ9nokGCF1IXXXjjRXeJURehkYR11U0QdFHdBGlk");
            sb.Append("CIvuzKswikDIr5ZTt6mb/56zGhRnbB14Ls7L8/7e/+9534qKIl+ciaqTen46qw+lUwr35srFjpevLf7mYr2itadWfw3UXAJabj9pDM5uqrxzaHLvpy7Yk890nqaykO9t");
            sb.Append("/ptQ2jGvbR8uNH8y8lfRaMdctfxJWcB2C/cqJ2Mw1uaoKjSPNBsr92TuzAfJ2cWygLQh8C7T6MSw1lz5d3NGwW7GK858+S/AToMLNwzOfwDCMEsCbjs6Ds33DoVyxtA3");
            sb.Append("yFkseS49+GwLjy44w9fjrog9LWe23pdKsOLqGYOrC7BGkKFC52WAiQHmMHa1PmTP2/HxoHR7oc5w78U5vU2kshoYuIO+QcDbDeg5gO8FjJ2g6wRa2rFRb8N6rRHLVXK8");
            sb.Append("kdQ+EgHWmNhdmH2AiYqNUoI+wEFJDAECcBBuJiO14sfxFswerp8SARL8wAQ4Oj1AGz0ECPT/TqJmgWYGoJvJSS1YP6ZC/JR6UgTY6BmaROwKeYf+KBDI5AdaSUPNgd5B");
            sb.Append("PoGg8LZaeV8E+Onrn4KNNlioBAU/AWw0VB390wxyMhd26ixInNBgrqZ1QgRYMQXH4aWNXRRdUAgSQEcKKoovKBBgjxRWjygxe1IxXvRBzbDd9jUD/5hOTeVnYebzCbKa");
            sb.Append("DuySQpoSCArPD5weLfkib+mcR6fZSHTRGhpZ1voeJlXemS2F+2uiwbkUVzGD12QaSQHwC+pWScfjcgKbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Padlock_r_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Padlock_r_Reset()
        {
            _Padlock_r = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Padlock_r_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Padlock_r = null;
        #endregion
        #region Image Padlock_y
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Padlock_y.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Padlock_y_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Padlock_y, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Padlock_y_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_y.png
        /// </remarks>
        public static System.Drawing.Image Padlock_y_Cached
        {
            get
            {
                if (_Padlock_y == null) _Padlock_y = Padlock_y;
                return _Padlock_y;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Padlock_y.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Padlock_y_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Padlock_y_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Padlock_y_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_y.png
        /// </remarks>
        public static System.Drawing.Image Padlock_y { get { return _ImageCreateFrom(_Padlock_y_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru Padlock_y.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Padlock_y_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Padlock_y_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\Padlock_y.png
        /// </remarks>
        public static System.Drawing.Image Padlock_y_FromFile { get { return _ImageCreateFrom(_Padlock_y_string, "Padlock_y.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Padlock_y
        /// </summary>
        /// <returns></returns>
        private static string _Padlock_y_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(880);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAACW0lEQVR4nIWSS0hVYRSF1z7/f8659xylTIK0RBCrgZMCoYcQiEgUQUEQDaImBUUhNCijQSA0CKJmQRLS");
            sb.Append("A6lB1LBBgiiEs5AKMoQSEW6IL67ee+79z//YDULQewT3aLNYfCzW3oQtZuTN1UMHWrwnOZ+Oa10x5ao3PjVr7p+7Pvy91ku1wqvHF/ed6Yp/BL7csVLCF7iqiEM+llTT");
            sb.Append("0tikPnr5zoefG/1eLeBIR3Qj9Hnnt+m1/tbuwROtPa+7ZuZFX13k1+8KFx7U+jOAujx3JhWN0a/FwXXt3aeZ5yplJbjcuS1AyDDSxmK5qJJ17enQmHHsaees2BYA/C8m");
            sb.Append("nws2abyVEYBcXx7ePR/1dO0/5cvVVpCPK2fbn13ovbakDC2UEjvJrIgylW+4wvTIrUcte8L+pJIi1Yy4rh7OKhitoFMFsmVM/fqTyPzul7N/1ftL90bGNyXw/Lz0o0ZE");
            sb.Append("3gpCtYYglEiTNYA0SDKKZYfm5qZIq7Wb81jKA9gMgKvKtFQAM4NkDGMcLCQsWzi2iKMAWjLKLoD0Q5fpQMic8HwJIglrFIQQsEghSYMFwzLAksDsEISRyVxBBnkp/BjO");
            sb.Append("VOB0CQQG4MGxgLGEVDOMYRhjoJTmTAJnEqkrq2DnQDKGdQwHAYYBESAEwVkgCEL4AdlMgmq5WPFECJlrABFBCA+CUwjSEB6DCPA8gjEajg1nAAdPvuj7PLHYPTdXGK4m");
            sb.Append("qxVmhiMJyz5S40FrhjEOzjksLy6UMn+wcQZun2443NHUu7eR2uPQtOUCbvPItaUq9X8X7MDH0cLQ4NsJCwD/ANkKHcvR7y/hAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Padlock_y_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Padlock_y_Reset()
        {
            _Padlock_y = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Padlock_y_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Padlock_y = null;
        #endregion
		#region Image Script
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku script.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Script_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Script, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Script_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\script.png
		/// </remarks>
		public static System.Drawing.Image Script_Cached
		{
			get
			{
				if (_Script == null) _Script = Script;
				return _Script;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku script.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Script_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Script_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Script_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\script.png
		/// </remarks>
		public static System.Drawing.Image Script { get { return _ImageCreateFrom(_Script_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru script.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Script_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Script_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\script.png
		/// </remarks>
		public static System.Drawing.Image Script_FromFile { get { return _ImageCreateFrom(_Script_string, "script.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Script
		/// </summary>
		/// <returns></returns>
		private static string _Script_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1640);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAopJREFUOMtV0z9olWcUx/Hv8zzve9/7J7nvbTQkSEiIUwdR7JA2iLRQKoJD5+KSsWOKk4KTc6EOTo6aTYdODXVVkIoOLmppqxgJicnN9f7P");
			sb.Append("+/w7DvfmTw+c7ZzP4fnBo0QEgJWHG0vAb6cb5eWBiwxcxMXI0Mc20AV2gQC0gCZwD/gzYVzR+6/PzU4sX/t2muPVtzEf2Ji39sOcddAtAu92e/zxb/8HYPU4MFMvKQA2");
			sb.Append("PgVSpUgUmASyVDOfaYzWpAbOz1U4ldem7v61+as+AIJz9VoCPkLXKtoOPhXQ3h91cwgfewGA62vvWV6sceZkOp0cA6YmS5p+Af39gNaKBDAGtAGDwiiIgAodnv7X4sX7");
			sb.Append("9uYRYO1MXjG0h55BIWgtGA06KIwGg2AMIIbtTsHtR/90gJVDwFu7MFNPae8LHkDABIWWUfYGIRFNFAhpwFu/+PsvF/aOMrDFwmye0beC0mCUQgMaUOMZJSACvigItggA");
			sb.Append("CcDlW+uVxOhSlmpsCGgEEEbHR+sK0BpcCPT6Aw90GB/AF3Y6U6DHISHjBRRKxkMoKik0ewW+sNvrNy/LIRBsUU2IJBqMVqA0iBphCmJUIFBNNDutIcEWmwdP1xdX1056");
			sb.Append("a28tfTnPVkd4tx3Y6wb6FoIISgmlElTKUK9CszPAW7t9ACTB2u+BK89fvaU1TOgVggtC4RTWR3yIRBGm8pyfL82y1RwQrN05Apz76sfvzlZuXP3mf38gCLggWD/K5M76");
			sb.Append("JtUUur0BwbnmceDt1m6b+49e0Zio0KiXadQy8lrGZLVEVtJkieanizNkCezsdQnOfTgEovcPHj97Pff42esF4MS4vxh3Xi6labmcUq9VaNSrvHyz8Tfw5AD4DHuKOyw+");
			sb.Append("R2uMAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE3LTA3OjAwWwD+wQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwNjo1MzowMS0wNzow");
			sb.Append("MFMpnckAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTM6MDEtMDc6MDAidCV1AAAAYnRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3Jn");
			sb.Append("L2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uGPGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMt");
			sb.Append("MTJUMjE6NTY6NTQtMDc6MDC7sdodAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk");
			sb.Append("+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Script_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Script_Reset()
		{
			_Script = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Script_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Script = null;
		#endregion
		#region Image TimeAdd
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku time-add.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu TimeAdd_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property TimeAdd, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TimeAdd_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\time-add.png
		/// </remarks>
		public static System.Drawing.Image TimeAdd_Cached
		{
			get
			{
				if (_TimeAdd == null) _TimeAdd = TimeAdd;
				return _TimeAdd;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku time-add.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image TimeAdd_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TimeAdd_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TimeAdd_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\time-add.png
		/// </remarks>
		public static System.Drawing.Image TimeAdd { get { return _ImageCreateFrom(_TimeAdd_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru time-add.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TimeAdd_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TimeAdd_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\time-add.png
		/// </remarks>
		public static System.Drawing.Image TimeAdd_FromFile { get { return _ImageCreateFrom(_TimeAdd_string, "time-add.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru TimeAdd
		/// </summary>
		/// <returns></returns>
		private static string _TimeAdd_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1800);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAEAAAABAAXMatwwAAAwNJREFUOMulk0tsVGUYhp9zhsOZzuXMpdSW2tISYETKpTUwaZohQYGFt1g2RjcGwbho0agLUjF0odbSoAuiTkJINBgXVk1IgBhtk2JFbSGa");
			sb.Append("io21o9HGWoZO28ylczlz5lx+dyPixsRv+ebLk3fxvJIQgv9za+4Mvhw+/YDqKryiuivtLsXlty2BXtTTxQKTulUz9NizAxO3/0u3N7j6yWA8GFw9GmrpXqtqdaieEEI4");
			sb.Append("FLJJ0gszJGevFHN5ZejxF95+7V+A8eE3zjRtDj8fbnmI5ZKf6d9yLGVKWLYg5HfTtslHSPzOz199QGrJOn74xLnTVcDIh0Ox2uDKWGu0V5lJqqxkDXZuDhPUZAQS6ZzN");
			sb.Append("9dllfKrMvVqC7y6fL+mucOyZl9+dkgFcTuZEoGm/sqxrLKbLHNrXStgvSBcK+DQvG5o1ug9sIpV3WJG3Ub/xbo9dyrwEIAPIUqnDG27i+0Sa7ZFaSpZAURRGv/ic1VwO");
			sb.Append("0zAYGb3Ctsg6JmayNESiuEQlVgUIIYJub4jkSona2hoMW7DW42Fhfp7RsXEGBofw+72E7vJwK10mUNeKC6m+CjANE8cx0CsOhg2mA0u5PF6fj+kbP/Bw9yE69kQxLDBN");
			sb.Append("B+GUEY7424NiQb+VS/2yMeBtZG6xxJamAMhu7tvdydYd2/EENMauX2DyxkUMJ0P/x0UCTqVSbZDXGf9zZpzoPTVMTKVQVPC6FWJ7u1gX0rh6bZjZm5fYv3cPPU/00r47");
			sb.Append("QqohE+g81vimDGDL/jPziTk9bE7S7C/w3qcJ/riZRTJMJN3ks2/O0751F7Zss2v9QWzJpHNHF0BvVaRzrx7p86mFwfZ995OSo0z8ZJHN29iOILH8HD1P9vJg29GqtZem");
			sb.Append("4wycff2fKsdPPnVSsfLH61s8vuZIG8H1LSAsDp/t59FHDmDh0HfwfU6NPI3bpfLRhYtl6c41xvuPRK3y6ouybXatkUUdwLXKgpnfoGtdO2Nsaejg18Upvv3xaxbmcm9J");
			sb.Append("/3XOnccaTwE9gB/IA/HJd5J9fwHBeVbdlMUGCgAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNy0wNzowMFsA/sEAAAAldEVYdGRhdGU6Y3JlYXRl");
			sb.Append("ADIwMTAtMDEtMTFUMDY6NTI6NTEtMDc6MDD0C/iTAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUyOjUxLTA3OjAwhVZALwAAAGJ0RVh0TGljZW5zZQBo");
			sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAA");
			sb.Append("JXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIxOjU4OjUwLTA3OjAwUTfOvQAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJj");
			sb.Append("ZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAzdEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVO");
			sb.Append("RK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property TimeAdd_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void TimeAdd_Reset()
		{
			_TimeAdd = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití TimeAdd_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _TimeAdd = null;
		#endregion
		#region Image TriangleDown
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_d.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu TriangleDown_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property TriangleDown, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleDown_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown_Cached
		{
			get
			{
				if (_TriangleDown == null) _TriangleDown = TriangleDown;
				return _TriangleDown;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_d.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image TriangleDown_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDown_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDown_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown { get { return _ImageCreateFrom(_TriangleDown_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru trian_d.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDown_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDown_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d.png
		/// </remarks>
		public static System.Drawing.Image TriangleDown_FromFile { get { return _ImageCreateFrom(_TriangleDown_string, "trian_d.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru TriangleDown
		/// </summary>
		/// <returns></returns>
		private static string _TriangleDown_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(412);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
			sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAABugAAAboB6KsBBgAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAAAwdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnMg");
			sb.Append("aHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL7/G8xwAAAA9SURBVDhPY2AYBSSEgG8DCYrRlYI0+/0n0wCYZrIMQNZMsgHomkkyAJtmog3ApZkoA/BpJsoAMiNqaGsD");
			sb.Append("AMNAKtUeiCc1AAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property TriangleDown_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void TriangleDown_Reset()
		{
			_TriangleDown = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití TriangleDown_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _TriangleDown = null;
		#endregion
		#region Image TriangleRight
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_r.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu TriangleRight_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property TriangleRight, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleRight_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight_Cached
		{
			get
			{
				if (_TriangleRight == null) _TriangleRight = TriangleRight;
				return _TriangleRight;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku trian_r.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image TriangleRight_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight { get { return _ImageCreateFrom(_TriangleRight_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru trian_r.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRight_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRight_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r.png
		/// </remarks>
		public static System.Drawing.Image TriangleRight_FromFile { get { return _ImageCreateFrom(_TriangleRight_string, "trian_r.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru TriangleRight
		/// </summary>
		/// <returns></returns>
		private static string _TriangleRight_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(404);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
			sb.Append("OpgAABdwnLpRPAAAAAlwSFlzAAABugAAAboB6KsBBgAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAAAwdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnMg");
			sb.Append("aHR0cDovL3d3dy5veHlnZW4taWNvbnMub3JnL7/G8xwAAAA1SURBVDhPY2AYzsDvP4W+AxlAkSEgzb4NFBgCs51sQ5CdT5YhVHEBWTbDIo8qsUBhShgh2gGcNRjSJn9H");
			sb.Append("swAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property TriangleRight_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void TriangleRight_Reset()
		{
			_TriangleRight = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití TriangleRight_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _TriangleRight = null;
		#endregion
        #region Image TriangleDownHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_d_h.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu TriangleDownHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property TriangleDownHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleDownHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot_Cached
        {
            get
            {
                if (_TriangleDownHot == null) _TriangleDownHot = TriangleDownHot;
                return _TriangleDownHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_d_h.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image TriangleDownHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot { get { return _ImageCreateFrom(_TriangleDownHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru trian_d_h.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_d_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleDownHot_FromFile { get { return _ImageCreateFrom(_TriangleDownHot_string, "trian_d_h.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru TriangleDownHot
        /// </summary>
        /// <returns></returns>
        private static string _TriangleDownHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(648);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA");
            sb.Append("CXBIWXMAAAG5AAABuQFFEiBrAAAAMHRFWHRTb3VyY2UAT3h5Z2VuIEljb25zIGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy+/xvMcAAAAGXRFWHRTb2Z0d2FyZQBQ");
            sb.Append("YWludC5ORVQgdjMuNS44NzuAXQAAAPlJREFUOE9jYKAX2PdIjxGIhYFYCohlgFgAiJmIth+omBeIzYHYCYgt9z3WkznwVI+FKANANgGxJhCXAHHZ/sd60UDN6qQYIGzm");
            sb.Append("4LIZaOtuoOZ1QI0VeA2A+hfkZzB2C3Y8w8Dg93/vY93fQI2niTWAE6iZMyDe7j5IMwgDNYIw8QbomrqugGkm1QBFGw/nPciaiTIAGtrCtp5O+9A14zUAGligeNYEhTY2");
            sb.Append("zYQMAKUwc2s35124NBMyQA5oQAgQzwDG8x1oaMNCHZ3GjAWgRnsgrgFq3gXU/IoAxmpABDCVtQE1riQCz8FISEDN9kBBfyKxD1CdIywpAwAkKmEIgjd/ugAAAABJRU5E");
            sb.Append("rkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property TriangleDownHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void TriangleDownHot_Reset()
        {
            _TriangleDownHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití TriangleDownHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _TriangleDownHot = null;
        #endregion
        #region Image TriangleRightHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_r_h.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu TriangleRightHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property TriangleRightHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property TriangleRightHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot_Cached
        {
            get
            {
                if (_TriangleRightHot == null) _TriangleRightHot = TriangleRightHot;
                return _TriangleRightHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku trian_r_h.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image TriangleRightHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRightHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRightHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot { get { return _ImageCreateFrom(_TriangleRightHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru trian_r_h.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití TriangleRightHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property TriangleRightHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\trian_r_h.png
        /// </remarks>
        public static System.Drawing.Image TriangleRightHot_FromFile { get { return _ImageCreateFrom(_TriangleRightHot_string, "trian_r_h.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru TriangleRightHot
        /// </summary>
        /// <returns></returns>
        private static string _TriangleRightHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(620);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAA");
            sb.Append("CXBIWXMAAAG5AAABuQFFEiBrAAAAMHRFWHRTb3VyY2UAT3h5Z2VuIEljb25zIGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy+/xvMcAAAAGXRFWHRTb2Z0d2FyZQBQ");
            sb.Append("YWludC5ORVQgdjMuNS44NzuAXQAAAOVJREFUOE9jYKAl2P9cX4Es8/c/0V134KnefxAGsreSbMiBJ7pfGBj8wAZADNErIcmQ/U/13oIMINuQA0/0XoM0xxfZohryTLeQ");
            sb.Append("KJcceKr7EmZ7XCGaIY90awgaAvT3c7jzH+mtBhryD9k7Bx7q2uI15MBT/ccwDe6hjmfB7GfQAH2s+3f/Ux0NvAbsf6wDjgX0MACGDdAgnVkEvbDvid43eCxAbQZH52Pd");
            sb.Append("AoKaQQqA8f4Txc9Pdd/vf6TnQZRmkCJQQoIlogOPdb/vf6JvQLRmiAt0aoFRuRdoyLv9z3UTSNJMd8UAKMC3yb6T6eAAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property TriangleRightHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void TriangleRightHot_Reset()
        {
            _TriangleRightHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití TriangleRightHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _TriangleRightHot = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
		/// <summary>
		/// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
		/// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
		/// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
		/// Pokud soubor neexistuje, nejprve se vytvoří.
		/// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
		/// Obsah obrázku definuje metoda getDataMethod.
		/// </summary>
		/// <param name="getDataMethod"></param>
		/// <param name="cacheFileName"></param>
		/// <returns></returns>
		private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
		{
			System.Drawing.Image image;
			if (cacheFileName == null)
			{
				using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
				{
					image = System.Drawing.Image.FromStream(ms);
				}
				return image;
			}
			string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
			if (!System.IO.File.Exists(fileName))
				System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
			if (System.IO.File.Exists(fileName))
				return Image.FromFile(fileName);
			return null;
		}
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Noris.Tools.TraceVisualiser.Support.Steward.GetUserAppDataPath(@"IconCache\Pics16");
                return __ImageCacheDir;
            }
        }
        private static string __ImageCacheDir;
		/// <summary>
		/// Předpis pro metody, které generují obsah souboru s daty
		/// </summary>
		/// <returns></returns>
		private delegate string _GetStringDelegate();
		/// <summary>
		/// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Icon vytvořená z dat</returns>
		public static System.Drawing.Icon ConvertStringToIcon(string data)
		{
			System.Drawing.Icon icon;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				icon = new System.Drawing.Icon(ms);
			}
			return icon;
		}
		/// <summary>
		/// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Cursor vytvořený z dat</returns>
		public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
		{
			System.Windows.Forms.Cursor cursor;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				cursor = new System.Windows.Forms.Cursor(ms);
			}
			return cursor;
		}
		#endregion
	}
}
